From fc6ecd7dae3c79638cb6d6542ab14fd324ac94e1 Mon Sep 17 00:00:00 2001 From: Andrei Podkovyrov Date: Thu, 1 Aug 2024 02:05:10 +0100 Subject: [PATCH 1/2] Update schema.tl, implement listBlockTransactionsExt method --- src/client.ts | 29 ++++++++++++++++++ src/schema.tl | 2 ++ src/schema.ts | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 114 insertions(+) diff --git a/src/client.ts b/src/client.ts index 6cff843..10a87f3 100644 --- a/src/client.ts +++ b/src/client.ts @@ -498,6 +498,35 @@ export class LiteClient { }, queryArgs); } + listBlockTransactionsExt = async (block: BlockID, args?: { + mode: number, + count: number, + after?: liteServer_transactionId3 | null | undefined, + wantProof?: boolean + }, queryArgs?: QueryArgs) => { + + let mode = args?.mode || 1 + 2 + 4; + let count = args?.count || 100; + let after: liteServer_transactionId3 | null = args && args.after ? args.after : null; + + return await this.engine.query(Functions.liteServer_listBlockTransactionsExt, { + kind: 'liteServer.listBlockTransactionsExt', + id: { + kind: 'tonNode.blockIdExt', + seqno: block.seqno, + shard: block.shard, + workchain: block.workchain, + rootHash: block.rootHash, + fileHash: block.fileHash + }, + mode, + count, + reverseOrder: null, + after, + wantProof: null + }, queryArgs); + } + getFullBlock = async (seqno: number) => { // MC Blocks diff --git a/src/schema.tl b/src/schema.tl index e31ab42..a2086b8 100644 --- a/src/schema.tl +++ b/src/schema.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:bytes 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; @@ -76,6 +77,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/src/schema.ts b/src/schema.ts index 3a25b72..b0dc495 100644 --- a/src/schema.ts +++ b/src/schema.ts @@ -197,6 +197,15 @@ export interface liteServer_blockTransactions { readonly proof: TLBytes; } +export interface liteServer_blockTransactionsExt { + readonly kind: 'liteServer.blockTransactionsExt'; + readonly id: tonNode_blockIdExt; + readonly reqCount: TLFlag; + readonly incomplete: TLBool; + readonly transactions: TLBytes; + readonly proof: TLBytes; +} + export interface liteServer_signature { readonly kind: 'liteServer.signature'; readonly nodeIdShort: TLInt256; @@ -330,6 +339,8 @@ export type liteServer_TransactionId3 = liteServer_transactionId3; export type liteServer_BlockTransactions = liteServer_blockTransactions; +export type liteServer_BlockTransactionsExt = liteServer_blockTransactionsExt; + export type liteServer_Signature = liteServer_signature; export type liteServer_SignatureSet = liteServer_signatureSet; @@ -459,6 +470,16 @@ export interface liteServer_listBlockTransactions { readonly wantProof: TLBool | null; } +export interface liteServer_listBlockTransactionsExt { + readonly kind: 'liteServer.listBlockTransactionsExt'; + readonly id: tonNode_blockIdExt; + readonly mode: TLFlag; + readonly count: TLFlag; + readonly after: liteServer_transactionId3 | null; + readonly reverseOrder: TLBool | null; + readonly wantProof: TLBool | null; +} + export interface liteServer_getBlockProof { readonly kind: 'liteServer.getBlockProof'; readonly mode: TLFlag; @@ -600,6 +621,11 @@ export const Functions = { decodeResponse: (decoder: TLReadBuffer) => Codecs.liteServer_BlockTransactions.decode(decoder) } as TLFunction, + liteServer_listBlockTransactionsExt: { + encodeRequest: (src: liteServer_listBlockTransactionsExt, encoder: TLWriteBuffer) => { encoder.writeInt32(7986524); Codecs.liteServer_listBlockTransactionsExt.encode(src, encoder); }, + decodeResponse: (decoder: TLReadBuffer) => Codecs.liteServer_BlockTransactionsExt.decode(decoder) + } as TLFunction, + liteServer_getBlockProof: { encodeRequest: (src: liteServer_getBlockProof, encoder: TLWriteBuffer) => { encoder.writeInt32(-1964336060); Codecs.liteServer_getBlockProof.encode(src, encoder); }, decodeResponse: (decoder: TLReadBuffer) => Codecs.liteServer_PartialBlockProof.decode(decoder) @@ -1021,6 +1047,24 @@ export const Codecs = { }, } as TLCodec, + liteServer_blockTransactionsExt: { + encode: (src: liteServer_blockTransactionsExt, encoder: TLWriteBuffer) => { + Codecs.tonNode_blockIdExt.encode(src.id, encoder); + encoder.writeUInt32(src.reqCount); + encoder.writeBool(src.incomplete); + encoder.writeBuffer(src.transactions); + encoder.writeBuffer(src.proof); + }, + decode: (decoder: TLReadBuffer): liteServer_blockTransactionsExt => { + let id = Codecs.tonNode_blockIdExt.decode(decoder); + let reqCount = decoder.readUInt32(); + let incomplete = decoder.readBool(); + let transactions = decoder.readBuffer(); + let proof = decoder.readBuffer(); + return { kind: 'liteServer.blockTransactionsExt', id, reqCount, incomplete, transactions, proof }; + }, + } as TLCodec, + liteServer_signature: { encode: (src: liteServer_signature, encoder: TLWriteBuffer) => { encoder.writeInt256(src.nodeIdShort); @@ -1393,6 +1437,26 @@ export const Codecs = { }, } as TLCodec, + liteServer_listBlockTransactionsExt: { + encode: (src: liteServer_listBlockTransactionsExt, encoder: TLWriteBuffer) => { + Codecs.tonNode_blockIdExt.encode(src.id, encoder); + encoder.writeUInt32(src.mode); + encoder.writeUInt32(src.count); + (src.mode & (1 << 7)) && !!src.after && Codecs.liteServer_transactionId3.encode(src.after, encoder); + (src.mode & (1 << 6)) && !!src.reverseOrder && encoder.writeBool(src.reverseOrder); + (src.mode & (1 << 5)) && !!src.wantProof && encoder.writeBool(src.wantProof); + }, + decode: (decoder: TLReadBuffer): liteServer_listBlockTransactionsExt => { + let id = Codecs.tonNode_blockIdExt.decode(decoder); + let mode = decoder.readUInt32(); + let count = decoder.readUInt32(); + let after = (mode & (1 << 7)) ? Codecs.liteServer_transactionId3.decode(decoder) : null; + let reverseOrder = (mode & (1 << 6)) ? decoder.readBool() : null; + let wantProof = (mode & (1 << 5)) ? decoder.readBool() : null; + return { kind: 'liteServer.listBlockTransactionsExt', id, mode, count, after, reverseOrder, wantProof }; + }, + } as TLCodec, + liteServer_getBlockProof: { encode: (src: liteServer_getBlockProof, encoder: TLWriteBuffer) => { encoder.writeUInt32(src.mode); @@ -1965,6 +2029,25 @@ export const Codecs = { }, } as TLCodec, + liteServer_BlockTransactionsExt: { + encode: (src: liteServer_BlockTransactionsExt, encoder: TLWriteBuffer) => { + const kind = src.kind; + if (kind === 'liteServer.blockTransactionsExt') { + encoder.writeInt32(-74449692); + Codecs.liteServer_blockTransactionsExt.encode(src, encoder); + return; + } + throw Error('Unknown type: ' + kind); + }, + decode: (decoder: TLReadBuffer): liteServer_BlockTransactionsExt => { + const kind = decoder.readInt32(); + if (kind === -74449692) { + return Codecs.liteServer_blockTransactionsExt.decode(decoder); + } + throw Error('Unknown type: ' + kind); + }, + } as TLCodec, + liteServer_Signature: { encode: (src: liteServer_Signature, encoder: TLWriteBuffer) => { const kind = src.kind; From 6cfd828f583b2d59bf8602d1908f20816fa77b3e Mon Sep 17 00:00:00 2001 From: Andrei Podkovyrov Date: Thu, 1 Aug 2024 02:05:20 +0100 Subject: [PATCH 2/2] Remove unused imports --- src/client.ts | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/client.ts b/src/client.ts index 10a87f3..78cb3fd 100644 --- a/src/client.ts +++ b/src/client.ts @@ -16,18 +16,17 @@ import { Account, Contract, openContract, - AccountState, loadShardStateUnsplit, StateInit } from "@ton/core"; import { LiteEngine } from "./engines/engine"; import { parseShards } from "./parser/parseShards"; -import { Functions, liteServer_blockHeader, liteServer_transactionId, liteServer_transactionId3, tonNode_blockIdExt } from "./schema"; +import { Functions, liteServer_blockHeader, liteServer_transactionId, liteServer_transactionId3 } from "./schema"; import DataLoader from 'dataloader'; import { crc16 } from "./utils/crc16"; import { createLiteClientProvider } from "./liteClientProvider"; import { LRUMap } from 'lru_map'; -import { AccountsDataLoaderKey, AllShardsResponse, BlockID, BlockLookupIDRequest, BlockLookupRequest, BlockLookupUtimeRequest, CacheMap, ClientAccountState, QueryArgs } from "./types"; +import { AccountsDataLoaderKey, AllShardsResponse, BlockID, BlockLookupRequest, CacheMap, ClientAccountState, QueryArgs } from "./types"; import { findIntersection, findOnlyOnFirst } from "./utils/arrays"; const ZERO = 0n;