From 3de0a17520f2d0f07f5f775cc29a7c15547c5dc2 Mon Sep 17 00:00:00 2001 From: ms Date: Wed, 13 Apr 2022 23:35:40 +0200 Subject: [PATCH 1/6] Add listBlockTransactionsExt method --- crypto/block/check-proof.cpp | 33 ++++++++ crypto/block/check-proof.h | 22 ++++++ tl/generate/scheme/lite_api.tl | 2 + tl/generate/scheme/lite_api.tlo | Bin 12896 -> 13512 bytes tl/generate/scheme/tonlib_api.tl | 2 + tl/generate/scheme/tonlib_api.tlo | Bin 28288 -> 28764 bytes tonlib/tonlib/TonlibClient.cpp | 105 ++++++++++++++++++++++++++ tonlib/tonlib/TonlibClient.h | 2 + validator/impl/liteserver.cpp | 120 ++++++++++++++++++++++++++++++ validator/impl/liteserver.hpp | 2 + 10 files changed, 288 insertions(+) diff --git a/crypto/block/check-proof.cpp b/crypto/block/check-proof.cpp index 6720ad407..ad760962c 100644 --- a/crypto/block/check-proof.cpp +++ b/crypto/block/check-proof.cpp @@ -315,6 +315,39 @@ td::Result TransactionList::validate() const { return std::move(res); } +td::Result BlockTransaction::validate() { + if (root.is_null()) { + return td::Status::Error("transactions are expected to be non-empty"); + } + block::gen::Transaction::Record trans; + if (!tlb::unpack_cell(root, trans)) { + return td::Status::Error("cannot unpack transaction #"); + } + Info res; + res.now = trans.now; + res.lt = trans.lt; + res.hash = root->get_hash().bits(); + res.transaction = root; + return std::move(res); +} + +td::Result BlockTransactionList::validate() const { + auto R = vm::std_boc_deserialize_multi(std::move(transactions_boc)); + if (R.is_error()) { + return td::Status::Error("cannot deserialize transactions BoC"); + } + auto list = R.move_as_ok(); + size_t c = 0; + Info res; + for (auto& root : list) { + BlockTransaction transaction; + transaction.root = root; + TRY_RESULT(info, transaction.validate()); + res.transactions.push_back(std::move(info)); + } + return std::move(res); +} + td::Status BlockProofLink::validate(td::uint32* save_utime) const { if (save_utime) { *save_utime = 0; diff --git a/crypto/block/check-proof.h b/crypto/block/check-proof.h index 527f31381..5ab872f94 100644 --- a/crypto/block/check-proof.h +++ b/crypto/block/check-proof.h @@ -88,4 +88,26 @@ struct TransactionList { td::Result validate() const; }; +struct BlockTransaction { + td::Ref root; + + struct Info { + td::uint32 now; + ton::LogicalTime lt; + ton::Bits256 hash; + td::Ref transaction; + }; + td::Result validate(); +}; + +struct BlockTransactionList { + td::BufferSlice transactions_boc; + + struct Info { + std::vector transactions; + }; + + td::Result validate() const; +}; + } // namespace block diff --git a/tl/generate/scheme/lite_api.tl b/tl/generate/scheme/lite_api.tl index d31ef5695..5aefd6ee4 100644 --- a/tl/generate/scheme/lite_api.tl +++ b/tl/generate/scheme/lite_api.tl @@ -44,6 +44,7 @@ liteServer.transactionList ids:(vector tonNode.blockIdExt) transactions:bytes = liteServer.transactionId mode:# account:mode.0?int256 lt:mode.1?long hash:mode.2?int256 = liteServer.TransactionId; liteServer.transactionId3 account:int256 lt:long = liteServer.TransactionId3; liteServer.blockTransactions id:tonNode.blockIdExt req_count:# incomplete:Bool ids:(vector liteServer.transactionId) proof:bytes = liteServer.BlockTransactions; +liteServer.blockTransactionsExt id:tonNode.blockIdExt req_count:# incomplete:Bool transactions:liteServer.transactionList proof:bytes = liteServer.BlockTransactionsExt; liteServer.signature node_id_short:int256 signature:bytes = liteServer.Signature; liteServer.signatureSet validator_set_hash:int catchain_seqno:int signatures:(vector liteServer.signature) = liteServer.SignatureSet; liteServer.blockLinkBack to_key_block:Bool from:tonNode.blockIdExt to:tonNode.blockIdExt dest_proof:bytes proof:bytes state_proof:bytes = liteServer.BlockLink; @@ -73,6 +74,7 @@ liteServer.getOneTransaction id:tonNode.blockIdExt account:liteServer.accountId liteServer.getTransactions count:# account:liteServer.accountId lt:long hash:int256 = liteServer.TransactionList; liteServer.lookupBlock mode:# id:tonNode.blockId lt:mode.1?long utime:mode.2?int = liteServer.BlockHeader; liteServer.listBlockTransactions id:tonNode.blockIdExt mode:# count:# after:mode.7?liteServer.transactionId3 reverse_order:mode.6?true want_proof:mode.5?true = liteServer.BlockTransactions; +liteServer.listBlockTransactionsExt id:tonNode.blockIdExt mode:# count:# after:mode.7?liteServer.transactionId3 reverse_order:mode.6?true want_proof:mode.5?true = liteServer.BlockTransactionsExt; liteServer.getBlockProof mode:# known_block:tonNode.blockIdExt target_block:mode.0?tonNode.blockIdExt = liteServer.PartialBlockProof; liteServer.getConfigAll mode:# id:tonNode.blockIdExt = liteServer.ConfigInfo; liteServer.getConfigParams mode:# id:tonNode.blockIdExt param_list:(vector int) = liteServer.ConfigInfo; diff --git a/tl/generate/scheme/lite_api.tlo b/tl/generate/scheme/lite_api.tlo index eb8e321137b650cc7badcf44cee0f92b7db944b6..83dbf4104dfc4aec932b5b694a95eb7f592f9f89 100644 GIT binary patch delta 183 zcmaEmaw3!W(QJJy1}M^h8$ z2AkJ%Oy<@FE6T|%NexadDoZWWOUlVl&JHO`%qvbzF3HT#D+cNXskwPf$cJ_ELLt@3 zlZ3q{=O{?9a3534pCn?y0+QWqB6353QF1e{syr8K%-u=`<;j0_6?l;JvQ56o?>@Oe MZw*Afg1!SY056b1b^rhX delta 59 zcmX?+`5=Y&(QJJy1}M = blocks.Shards; blocks.accountTransactionId account:bytes lt:int64 = blocks.AccountTransactionId; blocks.shortTxId mode:# account:mode.0?bytes lt:mode.1?int64 hash:mode.2?bytes = liteServer.TransactionId; blocks.transactions id:ton.blockIdExt req_count:int32 incomplete:Bool transactions:vector = blocks.Transactions; +blocks.transactionsExt id:ton.blockIdExt req_count:int32 incomplete:Bool transactions:vector = blocks.TransactionsExt; blocks.header id:ton.blockIdExt global_id:int32 version:int32 flags:# after_merge:Bool after_split:Bool before_split:Bool want_merge:Bool want_split:Bool validator_list_hash_short:int32 catchain_seqno:int32 min_ref_mc_seqno:int32 is_key_block:Bool prev_key_block_seqno:int32 start_lt:int64 end_lt:int64 gen_utime:int53 vert_seqno:# prev_blocks:vector = blocks.Header; //blocks.shortData header:blocks.Header transactions:blocks.Header = blocks.BlockData; @@ -296,6 +297,7 @@ blocks.getMasterchainInfo = blocks.MasterchainInfo; blocks.getShards id:ton.blockIdExt = blocks.Shards; blocks.lookupBlock mode:int32 id:ton.blockId lt:int64 utime:int32 = ton.BlockIdExt; blocks.getTransactions id:ton.blockIdExt mode:# count:# after:blocks.accountTransactionId = blocks.Transactions; +blocks.getTransactionsExt id:ton.blockIdExt mode:# count:# after:blocks.accountTransactionId = blocks.TransactionsExt; blocks.getBlockHeader id:ton.blockIdExt = blocks.Header; onLiteServerQueryResult id:int64 bytes:bytes = Ok; diff --git a/tl/generate/scheme/tonlib_api.tlo b/tl/generate/scheme/tonlib_api.tlo index 05c56ac08283bea94ca484f2c04acf3d2ac1d224..b7a03c157e71c6b4cea898505fe4a53f98004d3d 100644 GIT binary patch delta 165 zcmZp;%XsGjBk!Zx`c@235V4VWHM@+g-${S5q@4WZ>|(u;qQt!7#N?99{Jdh^s;P8#XWH+pVzK!9YQQ(PeXDfHTwPoZt^K E0Ni5{%K!iX diff --git a/tonlib/tonlib/TonlibClient.cpp b/tonlib/tonlib/TonlibClient.cpp index 8bcf53c97..44394deed 100644 --- a/tonlib/tonlib/TonlibClient.cpp +++ b/tonlib/tonlib/TonlibClient.cpp @@ -2390,6 +2390,75 @@ struct ToRawTransactions { return tonlib_api::make_object(std::move(transactions), std::move(transaction_id)); } + + td::Result> to_raw_transaction_or_throw( + block::BlockTransaction::Info&& info) { + std::string data; + + tonlib_api::object_ptr in_msg; + std::vector> out_msgs; + td::int64 fees = 0; + td::int64 storage_fee = 0; + if (info.transaction.not_null()) { + data = to_bytes(info.transaction); + block::gen::Transaction::Record trans; + if (!tlb::unpack_cell(info.transaction, trans)) { + return td::Status::Error("Failed to unpack Transaction"); + } + + TRY_RESULT_ASSIGN(fees, to_balance(trans.total_fees)); + //LOG(ERROR) << fees; + + //std::ostringstream outp; + //block::gen::t_Transaction.print_ref(outp, info.transaction); + //LOG(INFO) << outp.str(); + + auto is_just = trans.r1.in_msg->prefetch_long(1); + if (is_just == trans.r1.in_msg->fetch_long_eof) { + return td::Status::Error("Failed to parse long"); + } + if (is_just == -1) { + auto msg = trans.r1.in_msg->prefetch_ref(); + TRY_RESULT(in_msg_copy, to_raw_message(trans.r1.in_msg->prefetch_ref())); + in_msg = std::move(in_msg_copy); + } + + if (trans.outmsg_cnt != 0) { + vm::Dictionary dict{trans.r1.out_msgs, 15}; + for (int x = 0; x < trans.outmsg_cnt && x < 100; x++) { + TRY_RESULT(out_msg, to_raw_message(dict.lookup_ref(td::BitArray<15>{x}))); + fees += out_msg->fwd_fee_; + fees += out_msg->ihr_fee_; + out_msgs.push_back(std::move(out_msg)); + } + } + td::RefInt256 storage_fees; + if (!block::tlb::t_TransactionDescr.get_storage_fees(trans.description, storage_fees)) { + return td::Status::Error("Failed to fetch storage fee from transaction"); + } + storage_fee = storage_fees->to_long(); + } + return tonlib_api::make_object( + info.now, data, + tonlib_api::make_object(info.lt, + info.hash.as_slice().str()), + fees, storage_fee, fees - storage_fee, std::move(in_msg), std::move(out_msgs)); + } + + td::Result> to_raw_transaction(block::BlockTransaction::Info&& info) { + return TRY_VM(to_raw_transaction_or_throw(std::move(info))); + } + + td::Result>> to_raw_transactions( + block::BlockTransactionList::Info&& info) { + std::vector> transactions; + for (auto& transaction : info.transactions) { + TRY_RESULT(raw_transaction, to_raw_transaction(std::move(transaction))); + transactions.push_back(std::move(raw_transaction)); + } + + return transactions; + } }; // Raw @@ -4316,6 +4385,42 @@ td::Status TonlibClient::do_request(const tonlib_api::blocks_getTransactions& re return td::Status::OK(); } +td::Status TonlibClient::do_request(const tonlib_api::blocks_getTransactionsExt& request, + td::Promise>&& promise) { + TRY_RESULT(block, to_lite_api(*request.id_)) + TRY_RESULT(account, to_bits256((*request.after_).account_, "account")); + auto after = ton::lite_api::make_object(account, (*request.after_).lt_); + client_.send_query(ton::lite_api::liteServer_listBlockTransactionsExt( + std::move(block), + request.mode_, + request.count_, + std::move(after), + false, + false), + promise.wrap([](lite_api_ptr&& bTxes) { + const auto& id = bTxes->id_; + tonlib_api::blocks_transactionsExt r; + r.id_ = to_tonlib_api(*id); + r.req_count_ = bTxes->req_count_; + r.incomplete_ = bTxes->incomplete_; + // bTxes->transactions to block::BlockTransactionList::Info + block::BlockTransactionList list; + list.transactions_boc = std::move(bTxes->transactions_->transactions_); + auto info = list.validate(); + if (info.is_error()) { + LOG(ERROR) << "info.is_error()"; + } + // block::BlockTransactionList::Info to vector + auto raw_transactions = ToRawTransactions(td::optional()).to_raw_transactions(info.move_as_ok()); + if (raw_transactions.is_error()) { + LOG(ERROR) << "raw_transactions.is_error()"; + } + r.transactions_ = raw_transactions.move_as_ok(); + return tonlib_api::make_object(std::move(r)); + })); + return td::Status::OK(); +} + td::Status TonlibClient::do_request(const tonlib_api::blocks_getBlockHeader& request, td::Promise>&& promise) { TRY_RESULT(block, to_lite_api(*request.id_)) diff --git a/tonlib/tonlib/TonlibClient.h b/tonlib/tonlib/TonlibClient.h index 716133e46..63eadbfd7 100644 --- a/tonlib/tonlib/TonlibClient.h +++ b/tonlib/tonlib/TonlibClient.h @@ -354,6 +354,8 @@ class TonlibClient : public td::actor::Actor { td::Promise>&& promise); td::Status do_request(const tonlib_api::blocks_getTransactions& block_data, td::Promise>&& promise); + td::Status do_request(const tonlib_api::blocks_getTransactionsExt& request, + td::Promise>&& promise); td::Status do_request(const tonlib_api::blocks_getBlockHeader& request, td::Promise>&& promise); diff --git a/validator/impl/liteserver.cpp b/validator/impl/liteserver.cpp index 90d974e09..58e1d6d7b 100644 --- a/validator/impl/liteserver.cpp +++ b/validator/impl/liteserver.cpp @@ -178,6 +178,11 @@ void LiteQuery::start_up() { (q.mode_ & 128) ? q.after_->account_ : td::Bits256::zero(), static_cast((q.mode_ & 128) ? (q.after_->lt_) : 0)); }, + [&](lite_api::liteServer_listBlockTransactionsExt& q) { + this->perform_listBlockTransactionsExt(ton::create_block_id(q.id_), q.mode_, q.count_, + (q.mode_ & 128) ? q.after_->account_ : td::Bits256::zero(), + static_cast((q.mode_ & 128) ? (q.after_->lt_) : 0)); + }, [&](lite_api::liteServer_getConfigParams& q) { this->perform_getConfigParams(ton::create_block_id(q.id_), (q.mode_ & 0xffff) | 0x10000, q.param_list_); }, @@ -1853,6 +1858,121 @@ void LiteQuery::finish_listBlockTransactions(int mode, int req_count) { finish_query(std::move(b)); } +void LiteQuery::perform_listBlockTransactionsExt(BlockIdExt blkid, int mode, int count, Bits256 account, LogicalTime lt) { + LOG(INFO) << "started a listBlockTransactionsExt(" << blkid.to_str() << ", " << mode << ", " << count << ", " + << account.to_hex() << ", " << lt << ") liteserver query"; + base_blk_id_ = blkid; + acc_addr_ = account; + trans_lt_ = lt; + set_continuation([this, mode, count]() -> void { finish_listBlockTransactionsExt(mode, count); }); + request_block_data(blkid); +} + +void LiteQuery::finish_listBlockTransactionsExt(int mode, int req_count) { + LOG(INFO) << "completing a listBlockTransactionsExt(" << base_blk_id_.to_str() << ", " << mode << ", " << req_count + << ", " << acc_addr_.to_hex() << ", " << trans_lt_ << ") liteserver query"; + constexpr int max_answer_transactions = 256; + CHECK(block_.not_null()); + auto block_root = block_->root_cell(); + CHECK(block_root.not_null()); + RootHash rhash{block_root->get_hash().bits()}; + CHECK(rhash == base_blk_id_.root_hash); + vm::MerkleProofBuilder pb; + auto virt_root = block_root; + if (mode & 32) { + // proof requested + virt_root = pb.init(std::move(virt_root)); + } + if ((mode & 192) == 64) { // reverse order, no starting point + acc_addr_.set_ones(); + trans_lt_ = ~0ULL; + } + std::vector> trans_roots; + bool eof = false; + ton::LogicalTime reverse = (mode & 64) ? ~0ULL : 0; + try { + block::gen::Block::Record blk; + block::gen::BlockExtra::Record extra; + if (!(tlb::unpack_cell(virt_root, blk) && tlb::unpack_cell(std::move(blk.extra), extra))) { + fatal_error("cannot find account transaction data in block "s + base_blk_id_.to_str()); + return; + } + vm::AugmentedDictionary acc_dict{vm::load_cell_slice_ref(extra.account_blocks), 256, + block::tlb::aug_ShardAccountBlocks}; + int count = 0; + bool allow_same = true; + td::Bits256 cur_addr = acc_addr_; + while (!eof && count < req_count && count < max_answer_transactions) { + Ref value; + try { + value = acc_dict.extract_value( + acc_dict.vm::DictionaryFixed::lookup_nearest_key(cur_addr.bits(), 256, !reverse, allow_same)); + } catch (vm::VmError err) { + fatal_error("error while traversing account block dictionary: "s + err.get_msg()); + return; + } + if (value.is_null()) { + eof = true; + break; + } + allow_same = false; + if (cur_addr != acc_addr_) { + trans_lt_ = reverse; + } + block::gen::AccountBlock::Record acc_blk; + if (!(tlb::csr_unpack(std::move(value), acc_blk) && acc_blk.account_addr == cur_addr)) { + fatal_error("invalid AccountBlock for account "s + cur_addr.to_hex()); + return; + } + vm::AugmentedDictionary trans_dict{vm::DictNonEmpty(), std::move(acc_blk.transactions), 64, + block::tlb::aug_AccountTransactions}; + td::BitArray<64> cur_trans{(long long)trans_lt_}; + while (count < req_count && count < max_answer_transactions) { + Ref tvalue; + try { + tvalue = trans_dict.extract_value_ref( + trans_dict.vm::DictionaryFixed::lookup_nearest_key(cur_trans.bits(), 64, !reverse)); + } catch (vm::VmError err) { + fatal_error("error while traversing transaction dictionary of an AccountBlock: "s + err.get_msg()); + return; + } + if (tvalue.is_null()) { + trans_lt_ = reverse; + break; + } + trans_roots.push_back(std::move(tvalue)); + ++count; + } + } + } catch (vm::VmError err) { + fatal_error("error while parsing AccountBlocks of block "s + base_blk_id_.to_str() + " : " + err.get_msg()); + return; + } + td::BufferSlice proof_data; + if (mode & 32) { + // create proof + auto proof_boc = pb.extract_proof_boc(); + if (proof_boc.is_error()) { + fatal_error(proof_boc.move_as_error()); + return; + } + proof_data = proof_boc.move_as_ok(); + } + auto res = vm::std_boc_serialize_multi(std::move(trans_roots)); + if (res.is_error()) { + fatal_error(res.move_as_error()); + return; + } + + std::vector> blk_ids; + blk_ids.push_back(ton::create_tl_lite_block_id(base_blk_id_)); + auto transaction_list = create_tl_object(std::move(blk_ids), res.move_as_ok()); + auto b = ton::create_serialize_tl_object( + ton::create_tl_lite_block_id(base_blk_id_), req_count, !eof, std::move(transaction_list), std::move(proof_data)); + LOG(INFO) << "listBlockTransactionsExt() query completed"; + finish_query(std::move(b)); +} + void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to, int mode) { if (!(mode & 1)) { to.invalidate_clear(); diff --git a/validator/impl/liteserver.hpp b/validator/impl/liteserver.hpp index f1918cebc..b8ae4a2f2 100644 --- a/validator/impl/liteserver.hpp +++ b/validator/impl/liteserver.hpp @@ -133,6 +133,8 @@ class LiteQuery : public td::actor::Actor { void perform_lookupBlock(BlockId blkid, int mode, LogicalTime lt, UnixTime utime); void perform_listBlockTransactions(BlockIdExt blkid, int mode, int count, Bits256 account, LogicalTime lt); void finish_listBlockTransactions(int mode, int count); + void perform_listBlockTransactionsExt(BlockIdExt blkid, int mode, int count, Bits256 account, LogicalTime lt); + void finish_listBlockTransactionsExt(int mode, int count); void perform_getBlockProof(BlockIdExt from, BlockIdExt to, int mode); void continue_getBlockProof(BlockIdExt from, BlockIdExt to, int mode, BlockIdExt baseblk, Ref state); From a72ddadd6a9fdec5984fea919bfd057602c5ea5f Mon Sep 17 00:00:00 2001 From: ms Date: Thu, 14 Apr 2022 14:42:11 +0200 Subject: [PATCH 2/6] Add address field to raw.transaction --- tl/generate/scheme/tonlib_api.tl | 2 +- tonlib/tonlib/TonlibClient.cpp | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/tl/generate/scheme/tonlib_api.tl b/tl/generate/scheme/tonlib_api.tl index 9257035f3..1d8e70cef 100644 --- a/tl/generate/scheme/tonlib_api.tl +++ b/tl/generate/scheme/tonlib_api.tl @@ -51,7 +51,7 @@ ton.blockIdExt workchain:int32 shard:int64 seqno:int32 root_hash:bytes file_hash raw.fullAccountState balance:int64 code:bytes data:bytes last_transaction_id:internal.transactionId block_id:ton.blockIdExt frozen_hash:bytes sync_utime:int53 = raw.FullAccountState; raw.message source:accountAddress destination:accountAddress value:int64 fwd_fee:int64 ihr_fee:int64 created_lt:int64 body_hash:bytes msg_data:msg.Data = raw.Message; -raw.transaction utime:int53 data:bytes transaction_id:internal.transactionId fee:int64 storage_fee:int64 other_fee:int64 in_msg:raw.message out_msgs:vector = raw.Transaction; +raw.transaction address:accountAddress utime:int53 data:bytes transaction_id:internal.transactionId fee:int64 storage_fee:int64 other_fee:int64 in_msg:raw.message out_msgs:vector = raw.Transaction; raw.transactions transactions:vector previous_transaction_id:internal.transactionId = raw.Transactions; pchan.config alice_public_key:string alice_address:accountAddress bob_public_key:string bob_address:accountAddress init_timeout:int32 close_timeout:int32 channel_id:int64 = pchan.Config; diff --git a/tonlib/tonlib/TonlibClient.cpp b/tonlib/tonlib/TonlibClient.cpp index 44394deed..1ca2c17c3 100644 --- a/tonlib/tonlib/TonlibClient.cpp +++ b/tonlib/tonlib/TonlibClient.cpp @@ -2324,6 +2324,7 @@ struct ToRawTransactions { std::vector> out_msgs; td::int64 fees = 0; td::int64 storage_fee = 0; + td::string address; if (info.transaction.not_null()) { data = to_bytes(info.transaction); block::gen::Transaction::Record trans; @@ -2362,8 +2363,10 @@ struct ToRawTransactions { return td::Status::Error("Failed to fetch storage fee from transaction"); } storage_fee = storage_fees->to_long(); + address = trans.account_addr.as_slice().str(); } return tonlib_api::make_object( + tonlib_api::make_object(std::move(address)), info.now, data, tonlib_api::make_object(info.prev_trans_lt, info.prev_trans_hash.as_slice().str()), @@ -2399,6 +2402,7 @@ struct ToRawTransactions { std::vector> out_msgs; td::int64 fees = 0; td::int64 storage_fee = 0; + td::string address; if (info.transaction.not_null()) { data = to_bytes(info.transaction); block::gen::Transaction::Record trans; @@ -2437,8 +2441,10 @@ struct ToRawTransactions { return td::Status::Error("Failed to fetch storage fee from transaction"); } storage_fee = storage_fees->to_long(); + address = trans.account_addr.as_slice().str(); } return tonlib_api::make_object( + tonlib_api::make_object(std::move(address)), info.now, data, tonlib_api::make_object(info.lt, info.hash.as_slice().str()), From c2d93f6c1f08f887fc508bfa6ea33f00e22525d9 Mon Sep 17 00:00:00 2001 From: ms Date: Thu, 14 Apr 2022 22:46:52 +0200 Subject: [PATCH 3/6] Fix transaction address --- crypto/block/check-proof.cpp | 2 ++ crypto/block/check-proof.h | 4 ++++ tonlib/tonlib/TonlibClient.cpp | 7 +++++-- 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/crypto/block/check-proof.cpp b/crypto/block/check-proof.cpp index ad760962c..92dc69957 100644 --- a/crypto/block/check-proof.cpp +++ b/crypto/block/check-proof.cpp @@ -324,6 +324,7 @@ td::Result BlockTransaction::validate() { return td::Status::Error("cannot unpack transaction #"); } Info res; + res.blkid = blkid; res.now = trans.now; res.lt = trans.lt; res.hash = root->get_hash().bits(); @@ -342,6 +343,7 @@ td::Result BlockTransactionList::validate() const { for (auto& root : list) { BlockTransaction transaction; transaction.root = root; + transaction.blkid = blkid; TRY_RESULT(info, transaction.validate()); res.transactions.push_back(std::move(info)); } diff --git a/crypto/block/check-proof.h b/crypto/block/check-proof.h index 5ab872f94..6df18e593 100644 --- a/crypto/block/check-proof.h +++ b/crypto/block/check-proof.h @@ -89,9 +89,11 @@ struct TransactionList { }; struct BlockTransaction { + ton::BlockIdExt blkid; td::Ref root; struct Info { + ton::BlockIdExt blkid; td::uint32 now; ton::LogicalTime lt; ton::Bits256 hash; @@ -101,9 +103,11 @@ struct BlockTransaction { }; struct BlockTransactionList { + ton::BlockIdExt blkid; td::BufferSlice transactions_boc; struct Info { + ton::BlockIdExt blkid; std::vector transactions; }; diff --git a/tonlib/tonlib/TonlibClient.cpp b/tonlib/tonlib/TonlibClient.cpp index 1ca2c17c3..79120849c 100644 --- a/tonlib/tonlib/TonlibClient.cpp +++ b/tonlib/tonlib/TonlibClient.cpp @@ -2363,7 +2363,8 @@ struct ToRawTransactions { return td::Status::Error("Failed to fetch storage fee from transaction"); } storage_fee = storage_fees->to_long(); - address = trans.account_addr.as_slice().str(); + auto std_address = block::StdAddress(info.blkid.id.workchain, trans.account_addr); + address = std_address.rserialize(true); } return tonlib_api::make_object( tonlib_api::make_object(std::move(address)), @@ -2441,7 +2442,8 @@ struct ToRawTransactions { return td::Status::Error("Failed to fetch storage fee from transaction"); } storage_fee = storage_fees->to_long(); - address = trans.account_addr.as_slice().str(); + auto std_address = block::StdAddress(info.blkid.id.workchain, trans.account_addr); + address = std_address.rserialize(true); } return tonlib_api::make_object( tonlib_api::make_object(std::move(address)), @@ -4411,6 +4413,7 @@ td::Status TonlibClient::do_request(const tonlib_api::blocks_getTransactionsExt& r.incomplete_ = bTxes->incomplete_; // bTxes->transactions to block::BlockTransactionList::Info block::BlockTransactionList list; + list.blkid = create_block_id(id); list.transactions_boc = std::move(bTxes->transactions_->transactions_); auto info = list.validate(); if (info.is_error()) { From efb5ab4701b1c0e9ab4750ac2641f611cd339d0b Mon Sep 17 00:00:00 2001 From: ms Date: Fri, 15 Apr 2022 13:13:30 +0200 Subject: [PATCH 4/6] remove out_msgs limit --- tonlib/tonlib/TonlibClient.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tonlib/tonlib/TonlibClient.cpp b/tonlib/tonlib/TonlibClient.cpp index 79120849c..eb9efb1fa 100644 --- a/tonlib/tonlib/TonlibClient.cpp +++ b/tonlib/tonlib/TonlibClient.cpp @@ -2430,7 +2430,7 @@ struct ToRawTransactions { if (trans.outmsg_cnt != 0) { vm::Dictionary dict{trans.r1.out_msgs, 15}; - for (int x = 0; x < trans.outmsg_cnt && x < 100; x++) { + for (int x = 0; x < trans.outmsg_cnt; x++) { TRY_RESULT(out_msg, to_raw_message(dict.lookup_ref(td::BitArray<15>{x}))); fees += out_msg->fwd_fee_; fees += out_msg->ihr_fee_; From 9e84f0fd996c2749678ebb82f10f0ea1d8b85565 Mon Sep 17 00:00:00 2001 From: ms Date: Fri, 15 Apr 2022 13:40:42 +0200 Subject: [PATCH 5/6] build fix --- tonlib/tonlib/TonlibClient.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tonlib/tonlib/TonlibClient.cpp b/tonlib/tonlib/TonlibClient.cpp index eb9efb1fa..6242ff2f3 100644 --- a/tonlib/tonlib/TonlibClient.cpp +++ b/tonlib/tonlib/TonlibClient.cpp @@ -2465,7 +2465,7 @@ struct ToRawTransactions { transactions.push_back(std::move(raw_transaction)); } - return transactions; + return std::move(transactions); } }; From 9fa6fa28b1c71d971134408cb423ab3c8359de19 Mon Sep 17 00:00:00 2001 From: ms Date: Fri, 13 May 2022 18:06:48 +0200 Subject: [PATCH 6/6] fix tlo --- tl/generate/scheme/tonlib_api.tlo | Bin 28764 -> 28796 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/tl/generate/scheme/tonlib_api.tlo b/tl/generate/scheme/tonlib_api.tlo index b7a03c157e71c6b4cea898505fe4a53f98004d3d..669c168bd625d080b28abae27baf94eb4919749b 100644 GIT binary patch delta 91 zcmccffbq`*#tj-gEK&0_`ZnwEd{Bn46byXCWIJ!~`pzM&+= delta 83 zcmezKfbq@)#tj-gER8Kq1)FtvJ}5(23I;x6vLG@3qQr8&lA^@C;>6^V%=|o%*v(@? YJ{+4@y6H256;Hn7o&eG1;9;Wy0H8x5k^lez