Add stTON burn message handling

Author: shuva10v

tondb-scanner/src/InterfaceDetectors.hpp

@@ -552,8 +552,18 @@ class JettonWalletDetector: public InterfaceDetector<JettonWalletData> {
   void parse_burn_impl(JettonWalletData contract_data, schema::Transaction transaction, td::Ref<vm::CellSlice> cs, td::Promise<JettonBurn> promise) {
     tokens::gen::InternalMsgBody::Record_burn burn_record;
     if (!tlb::csr_unpack_inexact(cs, burn_record)) {
-      promise.set_error(td::Status::Error(ErrorCode::EVENT_PARSING_ERROR, "Failed to unpack burn"));
-      return;
+      // handle stTON burn message format
+      // burn#595f07bc query_id:uint64 jetton_amount:Coins = InternalMsgBody;
+      if (contract_data.jetton == "0:CD872FA7C5816052ACDF5332260443FAEC9AACC8C21CCA4D92E7F47034D11892") {
+        cs.write().skip_first(32); // opcode
+        if (!cs.write().fetch_ulong_bool(64, burn_record.query_id) || !tokens::gen::t_VarUInteger_16.fetch_to(cs.write(), burn_record.amount)) {
+          promise.set_error(td::Status::Error(ErrorCode::EVENT_PARSING_ERROR, "Failed to unpack stTON burn"));
+          return;
+        }
+      } else {
+        promise.set_error(td::Status::Error(ErrorCode::EVENT_PARSING_ERROR, "Failed to unpack burn"));
+        return;
+      }
     }
 
     JettonBurn burn;
@@ -580,14 +590,20 @@ class JettonWalletDetector: public InterfaceDetector<JettonWalletData> {
       promise.set_error(td::Status::Error(ErrorCode::EVENT_PARSING_ERROR, "Failed to unpack burn amount"));
       return;
     }
-    auto response_destination = convert::to_raw_address(burn_record.response_destination);
-    if (response_destination.is_error()) {
-      promise.set_error(response_destination.move_as_error());
-      return;
+    if (burn_record.response_destination.not_null()) {
+      auto response_destination = convert::to_raw_address(burn_record.response_destination);
+      if (response_destination.is_error()) {
+        promise.set_error(response_destination.move_as_error());
+        return;
+      }
+      burn.response_destination = response_destination.move_as_ok();
+    } else {
+      burn.response_destination = "addr_none";
     }
-    burn.response_destination = response_destination.move_as_ok();
     // since some messages don't have maybe ref cell at all we can ignore error here
-    burn_record.custom_payload_cell.write().fetch_maybe_ref(burn.custom_payload);
+    if (burn_record.custom_payload_cell.not_null()) {
+      burn_record.custom_payload_cell.write().fetch_maybe_ref(burn.custom_payload);
+    }
 
     promise.set_value(std::move(burn));
   }

tondb-scanner/test/tests.cpp

@@ -158,6 +158,64 @@ TEST(TonDbScanner, JettonWalletDetector_parse_burn_without_custom_payload) {
   scheduler.stop(); 
 }
 
+TEST(TonDbScanner, JettonWalletDetector_parse_burn_without_response_destination) {
+  /**
+   * The same situation as in the previous test - burn message doesn't have some required fields.
+   * stTON (bemo) burn message doesn't require response_destination field at all and
+   * in the documentation (https://docs.bemo.fi/developers/unstake) one can find a TL-B schema of the burn message:
+   * burn#595f07bc query_id:uint64 jetton_amount:Coins = InternalMsgBody;
+   *
+   * Since stTON is quite popular, it is worth to add it as an exception to the rule.
+   */
+  td::actor::Scheduler scheduler({1});
+  auto watcher = td::create_shared_destructor([] { td::actor::SchedulerContext::get()->stop(); });
+
+  // message payload for tx bea8befb0d6a928fa00e4ec4e6035b760ec12d4b339dd6cb2d53077fbf99c87f
+  auto message_payload = vm::load_cell_slice_ref(vm::std_boc_deserialize(td::base64_decode(
+    td::Slice("te6ccgEBAQEAFAAAI1lfB7wAAAAAAAAAAFU2CBF7qA==")).move_as_ok()).move_as_ok());
+
+  auto transaction = schema::Transaction();
+  transaction.account = block::StdAddress(std::string("EQCbVZsB2jOe0DGc0DSUA-gxqzfuAjBI7mCvIxuYmWkzBNl-")); // jetton wallet
+  transaction.in_msg = std::make_optional(schema::Message());
+  transaction.in_msg->source = "0:E27383455DD29192D213773AD731540C1D83CE03BB9C9D59A13A9800335EAC22"; // owner
+
+  td::actor::ActorId<InsertManagerInterface> insert_manager;
+  td::actor::ActorOwn<JettonWalletDetector> jetton_wallet_detector;
+  td::actor::ActorOwn<InterfaceManager> interface_manager;
+  td::actor::ActorOwn<JettonMasterDetector> jetton_master_detector;
+
+  // prepare jetton metadata
+  std::unordered_map<std::string, JettonWalletData> cache;
+  JettonWalletData jetton_master;
+  jetton_master.jetton = "0:CD872FA7C5816052ACDF5332260443FAEC9AACC8C21CCA4D92E7F47034D11892";
+  cache.emplace(std::string("0:9B559B01DA339ED0319CD0349403E831AB37EE023048EE60AF231B9899693304"), jetton_master);
+
+  scheduler.run_in_context([&] {
+    interface_manager = td::actor::create_actor<InterfaceManager>("interface_manager", insert_manager);
+    jetton_master_detector = td::actor::create_actor<JettonMasterDetector>("jetton_master_detector", interface_manager.get(), insert_manager);
+
+    jetton_wallet_detector = td::actor::create_actor<JettonWalletDetector>("jetton_wallet_detector",
+      jetton_master_detector.get(), interface_manager.get(), insert_manager, cache);
+
+    auto P = td::PromiseCreator::lambda([&transaction, &jetton_master](td::Result<JettonBurn> R) {
+      CHECK(R.is_ok());
+      auto burn = R.move_as_ok();
+      ASSERT_EQ(transaction.in_msg->source.value(), burn.owner);
+      ASSERT_EQ(convert::to_raw_address(transaction.account), burn.jetton_wallet);
+      ASSERT_EQ(jetton_master.jetton, burn.jetton_master);
+      ASSERT_EQ(0, burn.query_id);
+      ASSERT_TRUE(burn.custom_payload.is_null());
+      ASSERT_EQ(std::string("addr_none"), burn.response_destination);
+      CHECK(td::BigIntG<257>(358101358522) == **burn.amount.get());
+    });
+    td::actor::send_closure(jetton_wallet_detector, &JettonWalletDetector::parse_burn, transaction, message_payload, std::move(P));
+    watcher.reset();
+  });
+
+  scheduler.run(10);
+  scheduler.stop();
+}
+
 
 TEST(TonDbScanner, JettonWalletDetector) {
   td::actor::Scheduler scheduler({1});