@tonappchain/sdk 0.7.2-alpha-11 → 0.7.2-alpha-14

package/dist/artifacts/dev/ton/internal/build/CrossChainLayer.compiled.json

@@ -1 +1 @@
-{ "hash": "b7a220facd930fbfbf4b50baa2d2663dd81177c9e2de3f75973e40ddcac945a4", "hashBase64": "t6Ig+s2TD7+/S1C6otJmPdgRd8ni3j91lz5A3crJRaQ=", "hex": "b5ee9c7241024a010017d4000114ff00f4a413f4bcf2c80b010201200245020148032c02f4d0eda2edfb20c700925f04e001d0d30301ed44d0fa4001f861fa4001f862fa4001f863d401d0fa0001f86dfa0001f86cfa0030f86ed401d0d3ff01f864d430f871d401d0d32f01f86bd32f01f867d32f01f868d32f01f869d32f01f86ad30301f865f40430f866d430d0fa4001f86ffa0030f87071b0e302fa400406010a135f03db3c0501748020d721d31f0101d33f01123020821058d9b21bba9a30fa0030f85001a1f8708e1782100659627fba99fa0030f85001a0f8709430f2c096e2e24904f0fa4031fa0031f401fa0031fa00013170f83a02d31f0101d33f01125365a1f846f80701830cf94130f8075003a101a6668200c02b5003a0128209e1338070f8370170f836a066b6085210a1a6645177a123821048e660b5bae3022382106c582059bae300238210497dae1dbae3023035218210cda6f261ba07080e1900da6c818120ed70f8365cbcf2e064f84e59a1a0f86ec8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed5402fe04d31ffa00f404fa4055302170547000246ec0008e156c3101d0d300fa00fa0023963403fa0030039130e29134e255027f266ec000f84df84c5007a816a05240b915b0927034de5320a022a027a02f813c9170f836a0a052d0be5240b0e30210365f06298014fb02c88210ae7df95b2602cb1fcb3f12cb1f22cf16c9702802090d02fe333839393a3b5254a05006a05008a021a08014fb02f84e5003a0f86ec8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54266ec00092366de30d020a0b001a06c8f400f84dfa02f84cfa02c9019cc8cb1f2601cb3f5003cf1658fa02f40058cf16c982106c582059017f830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb0020d70b01c000b3915be30ddb310c0078c88210d53276db580302cb1fcb3fc970018010810082226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb0000748010810082226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb00f80fc000938100cc928064e2f2f00402fe333602fa40d4d4fa403001d0d3ff0101f404f401fa40fa0030f828f8515250027070500370c85004cf168b02cf1612ca000101cbffcb00c921c8cb0113f40012f400cb00c97001f90074c8cb0212ca07cbffc9d0500ac705f2e04704d7393078d721d3ff0131f8468307f40e6fa131f2e0c927c3009438333530e30d5424600f1102fe26044813505923d70b01c0008e6caa0081505d70f836a0738103b582100966018070f837a0801c8127e08209e1338070f837a0a47020c88210d7b9c06e580802cb1fcb3f23cf165004fa0258cf1671fa0214cb00cb00c9712070c87001ca0014cc13cb0012cb07cb07c9c858cf167f01ca0058fa02ccc9c8ccc9e30d2183073d10002af48e6fa56c1291a4923070e201d0028307f416040304fc54557428705470007f097009a1f84ea15007a18fd551898307f47c6fa5208fc402d430d0fa40d20001209301fa00927058e2d430d0d20001209301fa00927058e2d4f404069232348e95342291348e8d3103d307d3073001c001f2e0cee202e201e30f029132e201b319e65b36365b20c2009831f85001a1f8707f9130e21213161702ee7021c000965b705300f8388f6921c0018ee221c0028e5b21c0048e2a5b8209da9c008019812af85870f837aa008170ae70f836a08019812af870f83c79810f5a70f838a0a4a08e2901c0038e1f308209da9c0080198126955870f8378143e470f836a07281051470f838a4a093f2c0cee2e2e30de30de2414202b8f8502ca153e9a129a15330bc22c200b08ec85b5441145033206e8e2b3080108011226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb008e8cc802d012cf1680108011db3ce214a04313e30d2b1401d428a121a05230bbf2e0665220b608c882103c497a612d02cb1fcb3f2b01cbff21fa0223fa025005cf1613cc12f400c920f80701830cf94130f8075003a1801c813a8a8209e1338070f83781348f58a070f836a00270f838a703a081337270f836a0f84f54200380188010150062226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb0051a2a0507aa05066a113a0018e5441145033206e8e2b3080108011226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb008e8cc802d012cf1680108011db3ce215a044142b01e85253a1c200f2e064c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54c8500601cbff0101ca00c98210497dae1d01701800fa830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb005042a158a1f84e5210bef2e0658010fb0221d70b01c000b38e3bc88210d53276db5802cb1fcb3fc970018010810082226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb00915be204fe8ee031333403d3ff01f828f8515220027070500370c85004cf168b02cf1612ca000101cbffcb00c921c8cb0113f40012f400cb00c97001f90074c8cb0212ca07cbffc9d05005c705f2e047028014fb0201fa4030c82301cbffc98210cda6f261017fe021821074cd76b2bae302352082101f95f86cbae302208210063199b71a1b1c1d01e4830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb0020d70b01c000b38e40c8821086f27385580302cb1fcb3f5801cbffc970018010810082226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb00925f03e24900de5b3233f84313c705f2e04801d3ff0131f8648014fb02c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54019c10455f05f84ec300f2e0c8c88210f358b6d05802cb1fcb3ff84efa02c9f841f84e58801072226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb0070f86e4902feba8e69306c2232f841c705f2e046fa0030f86cc8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54e02082103531465cbae3022082105cec6be0ba1e1f00d2306c2232f841c705f2e046fa0030f86dc8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed5402fc8e69306c2232f841c705f2e046fa4030f863c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54e0208210581879bcbae30220821060094a1bba202100e4306c2232f841c705f2e046fa4030f862f8428b02c705f2d050c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed5403fe8e6810255f05f841c705f2e0468b02f862c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed54e02082106a4fbe34bae3022082106e7145f9bae30222232400d810255f05f842c705f2e049f842f8618b02f862c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed540026306c2232f841c705f2e046d401fb04d430ed5404e62082107ee5a6d0ba8ec0306c2232f841c705f2e046d430f8716df86682107ee5a6d0c8c970830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb00e0208210e97250b7bae302208210d53276dbba925f06e020821074db6fbdbae302208210149c7a93ba4925262700d4306c2232f841c705f2e046d32f0131f86bc8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed5400d2306c2232f841c705f2e046fa4030f86fc8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed5403f08eda30f84112c705f2e046fa00305033a15220bbf2e0cfc8821058d9b21b5802cb1fcb3f21fa02c9f84f522280188010226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb00f85001a0f870e0208210461d3038bae3023403821046a47169bae3025f04840ff2f049282901ba303233f84113c705f2e04601fa0030f8505210bbf2e0d0c882100659627f580302cb1fcb3f21fa02c9f84f705880188050226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb00f85001a1f8704901d8f84fc705f2e04a01f40430206eb38ed8d0d3ff0101fa40fa00d4f40430f84e17a15005a121be8e3e316c22c85801cbff01fa02c9821049e265430170830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb00f80ff2c065e30d925f03e22a01e64034206e8e2b3080108011226eb32091719170e2c8500401cb055006cf165004fa02cb6a039358cc019130e201c901fb008e8cc802d012cf1680108011db3ce2c80101cbffc9821046a471690170830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb002b00a28e4dc85801cb055005cf165003fa0254712323ed41ed43ed44ed45ed479f5bc85003cf17c913775003cb6bcccced67ed65ed64ed63ed61747fed11987601cb6bcc01cf17ed41edf101f2ffc901fb00db060201202d340201202e2f00d3bb769ed44d0fa4001f861fa4001f862fa4001f863d401d0fa0001f86dfa0001f86cfa0030f86ed401d0d3ff01f864d430f871d401d0d32f01f86bd32f01f867d32f01f868d32f01f869d32f01f86ad30301f865f40430f866d430d0fa4001f86ffa0030f870f84ff8508020120303201fbb444bda89a1f48003f0c3f48003f0c5f48003f0c7a803a1f40003f0dbf40003f0d9f40061f0dda803a1a7fe03f0c9a861f0e3a803a1a65e03f0d7a65e03f0cfa65e03f0d1a65e03f0d3a65e03f0d5a60603f0cbe80861f0cda861a1f48003f0dff40061f0e1f083f085f087f08bf08df08ff091f093f097f095f09bf0990310014f84ef851f844f84ff85001cbb4817da89a1f48003f0c3f48003f0c5f48003f0c7a803a1f40003f0dbf40003f0d9f40061f0dda803a1a7fe03f0c9a861f0e3a803a1a65e03f0d7a65e03f0cfa65e03f0d1a65e03f0d3a65e03f0d5a60603f0cbe80861f0cda861a1f48003f0dff40061f0e103300707020f8468307f4866fa5908e1801d32f01315303bc946c2251109130e2f8468307f47c6fa5e810235f03f847f848f849f84af84bf845f8440201203539020120363801d5b6d0bda89a1f48003f0c3f48003f0c5f48003f0c7a803a1f40003f0dbf40003f0d9f40061f0dda803a1a7fe03f0c9a861f0e3a803a1a65e03f0d7a65e03f0cfa65e03f0d1a65e03f0d3a65e03f0d5a60603f0cbe80861f0cda861a1f48003f0dff40061f0e1f051f0a225037006e027070500370c85004cf168b02cf1612ca000101cbffcb00c921c8cb0113f40012f400cb00c9207001f90074c8cb0212ca07cbffc9d001004fb7b17f00e030619f28261f00ea00742034ccd04018056a00740250413c26700e1f06e02e1f06d4100201203a4301fbb40f5f00e4b0619f28261f00ea00743f00fda89a1f48003f0c3f48003f0c5f48003f0c7a803a1f40003f0dbf40003f0d9f40061f0dda803a1a7fe03f0c9a861f0e3a803a1a65e03f0d7a65e03f0cfa65e03f0d1a65e03f0d3a65e03f0d5a60603f0cbe80861f0cda861a1f48003f0dff40061f0e011a1a7fe0261e8086103b02e87f5343a60381037a58a0820812750070f8375348a0a603536aa081037aa070f838525aa0526ba01a70f83818a07181012070f838a0533470f838aa00a082010abd5003a070f83612a017a0810c1c70f836a024c3008e8d70f828541343f83c1024435012926c41e28ae66c21f80758a170f836a03c3f02fe23d70b01c0008e6caa0081505d70f836a0738103b582100966018070f837a0801c8127e08209e1338070f837a0a47020c88210d7b9c06e580802cb1fcb3f23cf165004fa0258cf1671fa0214cb00cb00c9712070c87001ca0014cc13cb0012cb07cb07c9c858cf167f01ca0058fa02ccc9c8ccc9e30d238307f48e6fa56c123d3e0054306c22707121c8c9c87f01ca005006fa0215cc14cb0013cb0712cb07c9c858cf167001ca00ccc9c8ccc9001e91a4923070e201d040148307f41602019a51128307f47c6fa5208ebc02d430d0fa4031d20001209301fa00927058e2d430d0d2000192fa00927001e2d431f404310394303113a08e8d3101d307d3073001c001f2e0cee2029132e201b3124002fc7021c000965b705300f8388f6921c0018ee221c0028e5b21c0048e2a5b8209da9c008019812af85870f837aa008170ae70f836a08019812af870f83c79810f5a70f838a0a4a08e2901c0038e1f308209da9c0080198126955870f8378143e470f836a07281051470f838a4a093f2c0cee2e2e30de30de201a170b60913a04142005a5b8018811c488209e1338070f8377581058e82100966018070f837a08140b570f836a08024814bfa70f838a4a0005a5b801c8127e08209e1338070f8378208278d00738103b55870f837a081535370f836a08042815cb270f838a4a001d5b662dda89a1f48003f0c3f48003f0c5f48003f0c7a803a1f40003f0dbf40003f0d9f40061f0dda803a1a7fe03f0c9a861f0e3a803a1a65e03f0d7a65e03f0cfa65e03f0d1a65e03f0d3a65e03f0d5a60603f0cbe80861f0cda861a1f48003f0dff40061f0e1f051f0a225044006a027070500370c85004cf168b02cf1612ca000101cbffcb00c921c8cb0113f40012f400cb00c97001f90074c8cb0212ca07cbffc9d0013af220c7009130e0d31f840f0282104b19e42abd12f2f28308d71820f9014601faed44d0fa4001f861fa4001f862fa4001f863d401d0fa0001f86dfa0001f86cfa0030f86ed401d0d3ff01f864d430f871d401d0d32f01f86bd32f01f867d32f01f868d32f01f869d32f01f86ad30301f865f40430f866d430d0fa4001f86ffa0030f87001d3ff01f8445e21f910f2a0f84901d32f0131f869f823f849be4701fcf2e0cdf849f84abef2e0cbf800f848f867f823f868f848f84ba0f86af823f845f84ba8a1f8468307f4866fa5908e1c01d32f013122bb9bf84652108307f45b30f866def8468307f47c6fa5e85f03c8f84a01cb2fc9d0f84652308307f416f866c85801cbff0101cb2ff84901cb2ff84701cb2ff84801cb2ff84a01cb2fc948015a82104b19e42a017f830771800cc8cb03cb01cb0813cbff02957158cb61cc987058cb6101d0cf16e2c98010fb004900b2c8f84fcf16f850fa02c9f846f845c8f84b01cb2ff84701cb2ff84801cb2ff84901cb2ff84a01cb2fcb03f400c9f851c8f84401cbffccc9c8f84dfa02f84cfa02f84efa02c9c8f841cf16f842cf16f843cf16ccccccccc9ed547ddb5d57" }
+{ "hash": "85de6d2e111cbc56b64af4ac6e0c705806e37d984440d197ff4b6fb39439b672", "hashBase64": "hd5tLhEcvFa2SvSsbgxwWAbjfZhEQNGX/0tvs5Q5tnI=", "hex": "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" }

package/dist/src/adapters/BaseContractOpener.d.ts

@@ -0,0 +1,76 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ContractOpener, ILogger } from '../interfaces';
+import { AddressInformation, GetTransactionsOptions } from '../structs/Struct';
+import { ContractState, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+export declare abstract class BaseContractOpener implements ContractOpener {
+    protected logger?: ILogger;
+    protected constructor(logger?: ILogger);
+    setLogger(logger: ILogger): void;
+    abstract open<T extends Contract>(contract: T): OpenedContract<T> | SandboxContract<T>;
+    abstract getContractState(address: Address): Promise<ContractState>;
+    abstract getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    abstract getAddressInformation(address: Address): Promise<AddressInformation>;
+    abstract getConfig(): Promise<string>;
+    closeConnections?(): void;
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    private scanTransactionHistory;
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getTransactionByHash(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    getTransactionByTxHash(addr: Address, txHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     */
+    getTransactionByInMsgHash(addr: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     */
+    getTransactionByOutMsgHash(addr: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getAdjacentTransactions(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    /**
+     * Validate transaction phases and return error details
+     */
+    private validateTransactionWithResult;
+    /**
+     * Find transaction by hash type
+     */
+    private findTransactionByHashType;
+    /**
+     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     */
+    private findRootTransactionWithRetry;
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
+}

package/dist/src/adapters/BaseContractOpener.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContractOpener = void 0;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+class BaseContractOpener {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    setLogger(logger) {
+        if (!this.logger) {
+            this.logger = logger;
+        }
+    }
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    async scanTransactionHistory(addr, opts, predicate) {
+        const limit = opts?.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT;
+        const inclusive = opts?.inclusive ?? true;
+        const toLt = opts?.to_lt ? BigInt(opts.to_lt) : undefined;
+        let currentLt = opts?.lt;
+        let currentHash = opts?.hash ? (0, Utils_1.normalizeHashToBase64)(opts.hash) : undefined;
+        const seenCursors = new Set();
+        let scannedTransactions = 0;
+        const maxScannedTransactions = opts?.maxScannedTransactions ?? Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS;
+        while (true) {
+            const list = await this.getTransactions(addr, {
+                limit,
+                lt: currentLt,
+                hash: currentHash,
+                to_lt: opts?.to_lt,
+                inclusive,
+                archival: opts?.archival ?? Consts_1.DEFAULT_FIND_TX_ARCHIVAL,
+                timeoutMs: opts?.timeoutMs,
+                retryDelayMs: opts?.retryDelayMs,
+            });
+            if (list.length === 0) {
+                break;
+            }
+            let startIndex = 0;
+            const firstTx = list[0];
+            const firstTxMatchesCursor = currentLt &&
+                currentHash &&
+                firstTx.lt.toString() === currentLt &&
+                firstTx.hash().toString('base64') === currentHash;
+            if (firstTxMatchesCursor) {
+                startIndex = 1;
+                if (list.length === 1) {
+                    if (firstTx.prevTransactionLt === 0n) {
+                        break;
+                    }
+                    const nextLt = firstTx.prevTransactionLt.toString();
+                    const nextHash = Buffer.from(firstTx.prevTransactionHash.toString(16).padStart(64, '0'), 'hex').toString('base64');
+                    if (currentLt && BigInt(nextLt) >= BigInt(currentLt)) {
+                        break;
+                    }
+                    const cursorKey = `${nextLt}:${nextHash}`;
+                    if (seenCursors.has(cursorKey)) {
+                        break;
+                    }
+                    seenCursors.add(cursorKey);
+                    currentLt = nextLt;
+                    currentHash = nextHash;
+                    continue;
+                }
+            }
+            for (let i = startIndex; i < list.length; i++) {
+                const tx = list[i];
+                scannedTransactions += 1;
+                if (scannedTransactions > maxScannedTransactions) {
+                    this.logger?.debug(`Scan limit reached (${maxScannedTransactions} transactions), stopping history scan`);
+                    return null;
+                }
+                if (predicate(tx)) {
+                    return tx;
+                }
+            }
+            const oldestTx = list[list.length - 1];
+            if (oldestTx.prevTransactionLt === 0n)
+                break;
+            if (toLt !== undefined) {
+                if (inclusive ? oldestTx.lt <= toLt : oldestTx.lt < toLt)
+                    break;
+            }
+            const nextLt = oldestTx.lt.toString();
+            const nextHash = oldestTx.hash().toString('base64');
+            if (currentLt && BigInt(nextLt) >= BigInt(currentLt)) {
+                break;
+            }
+            const cursorKey = `${nextLt}:${nextHash}`;
+            if (seenCursors.has(cursorKey)) {
+                break;
+            }
+            seenCursors.add(cursorKey);
+            currentLt = nextLt;
+            currentHash = nextHash;
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getTransactionByHash(addr, hash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(hash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // 1. check tx itself
+            if (tx.hash().toString('base64') === targetHashB64) {
+                return true;
+            }
+            // 2. check incoming message(external-in)
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const msgHash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (msgHash === targetHashB64) {
+                    return true;
+                }
+                const rawMsgHash = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64');
+                if (rawMsgHash === targetHashB64) {
+                    return true;
+                }
+            }
+            // 3. check incoming message(internal)
+            if (tx.inMessage && tx.inMessage.info.type === 'internal') {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell();
+                const msgHash = messageCell.hash();
+                if (msgHash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            // 4. check outcoming message
+            for (const outMsg of tx.outMessages.values()) {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(outMsg)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    async getTransactionByTxHash(addr, txHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(txHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            return tx.hash().toString('base64') === targetHashB64;
+        });
+    }
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     */
+    async getTransactionByInMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // Check incoming message(external-in) - uses normalized hash
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const hash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (hash === targetHashB64) {
+                    return true;
+                }
+                const rawHash = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64');
+                if (rawHash === targetHashB64) {
+                    return true;
+                }
+            }
+            // Check incoming message(internal) - uses full message cell hash
+            if (tx.inMessage && tx.inMessage.info.type === 'internal') {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     */
+    async getTransactionByOutMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            for (const outMsg of tx.outMessages.values()) {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(outMsg)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getAdjacentTransactions(addr, hash, opts) {
+        // 1. Find the root transaction (hash will be normalized inside getTransactionByHash)
+        const rootTx = await this.getTransactionByHash(addr, hash, opts);
+        if (!rootTx)
+            return [];
+        const adjacent = [];
+        // 2. Follow every outgoing message to find child transactions
+        for (const msg of rootTx.outMessages.values()) {
+            const dst = msg.info.dest;
+            if (!dst || dst instanceof ton_1.ExternalAddress)
+                continue;
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64');
+            // The outgoing message becomes an incoming message at the destination
+            const tx = await this.getTransactionByInMsgHash(dst, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        // 3. Optional: follow the incoming message to find parent transaction
+        if (rootTx.inMessage?.info.type === 'internal') {
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(rootTx.inMessage)).endCell().hash().toString('base64');
+            // The incoming message was an outgoing message at the source
+            const tx = await this.getTransactionByOutMsgHash(rootTx.inMessage.info.src, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        return adjacent;
+    }
+    /**
+     * Validate transaction phases and return error details
+     */
+    validateTransactionWithResult(tx, ignoreOpcodeList) {
+        if (tx.description.type !== 'generic')
+            return null;
+        const { aborted, computePhase, actionPhase } = tx.description;
+        const txHash = tx.hash().toString('base64');
+        const exitCode = computePhase && computePhase.type !== 'skipped' ? computePhase.exitCode : 'N/A';
+        const resultCode = actionPhase ? actionPhase.resultCode : 'N/A';
+        if (aborted) {
+            return { txHash, exitCode, resultCode, reason: 'aborted' };
+        }
+        if (!computePhase) {
+            return { txHash, exitCode, resultCode, reason: 'compute_phase_missing' };
+        }
+        if (computePhase.type !== 'skipped' && (!computePhase.success || computePhase.exitCode !== 0)) {
+            return { txHash, exitCode, resultCode, reason: 'compute_phase_failed' };
+        }
+        if (actionPhase && (!actionPhase.success || actionPhase.resultCode !== 0)) {
+            return { txHash, exitCode, resultCode, reason: 'action_phase_failed' };
+        }
+        if (!tx.inMessage)
+            return null;
+        // Log optional skip hints (does not bypass phase validation)
+        if (tx.inMessage.info.type === 'internal' && tx.inMessage.info.value.coins === Consts_1.IGNORE_MSG_VALUE_1_NANO) {
+            this.logger?.debug(`Skipping extra checks for tx: ${txHash} (1 nano message)`);
+            return null;
+        }
+        const bodySlice = tx.inMessage.body.beginParse();
+        if (bodySlice.remainingBits >= 32) {
+            const opcode = bodySlice.loadUint(32);
+            if (ignoreOpcodeList.includes(opcode)) {
+                this.logger?.debug(`Skipping extra checks for tx: ${txHash} (opcode in ignore list)`);
+            }
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash type
+     */
+    async findTransactionByHashType(address, hash, hashType, opts) {
+        const searchOpts = { archival: true, ...opts };
+        if (hashType === 'in') {
+            return this.getTransactionByInMsgHash(address, hash, searchOpts);
+        }
+        else if (hashType === 'out') {
+            return this.getTransactionByOutMsgHash(address, hash, searchOpts);
+        }
+        else {
+            return this.getTransactionByHash(address, hash, searchOpts);
+        }
+    }
+    /**
+     * Retry lookup for root transaction because it may appear in indexers with a delay.
+     */
+    async findRootTransactionWithRetry(address, hash, hashType, limit, maxScannedTransactions, waitForRootTransaction) {
+        if (!waitForRootTransaction) {
+            return this.findTransactionByHashType(address, hash, hashType, {
+                limit,
+                archival: true,
+                maxScannedTransactions,
+            });
+        }
+        const attempts = Math.ceil(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_TIMEOUT_MS / Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        const broadSearchOpts = { limit, archival: true, maxScannedTransactions };
+        const baselineInfo = await this.getAddressInformation(address);
+        let seenLt = baselineInfo.lastTransaction.lt || undefined;
+        // Capture baseline before first search.
+        const firstTx = await this.findTransactionByHashType(address, hash, hashType, broadSearchOpts);
+        if (firstTx) {
+            this.logger?.debug(`Root transaction found on attempt 1/${attempts}`);
+            return firstTx;
+        }
+        this.logger?.debug(`Root transaction not found yet (attempt 1/${attempts}), retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+        await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        for (let attempt = 2; attempt <= attempts; attempt++) {
+            const info = await this.getAddressInformation(address);
+            const currentLt = info.lastTransaction.lt || undefined;
+            if (!currentLt || currentLt === seenLt) {
+                this.logger?.debug(`Root transaction not found yet (attempt ${attempt}/${attempts}), lastTx unchanged, retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+                await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+                continue;
+            }
+            seenLt = currentLt;
+            const tx = await this.findTransactionByHashType(address, hash, hashType, broadSearchOpts);
+            if (tx) {
+                this.logger?.debug(`Root transaction found on attempt ${attempt}/${attempts}`);
+                return tx;
+            }
+            this.logger?.debug(`Root transaction not found yet (attempt ${attempt}/${attempts}), retrying in ${Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS}ms`);
+            await (0, Utils_1.sleep)(Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION_RETRY_DELAY_MS);
+        }
+        this.logger?.debug(`Root transaction not found after ${attempts} attempts`);
+        return null;
+    }
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    async trackTransactionTree(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
+    }) {
+        const result = await this.trackTransactionTreeWithResult(address, hash, params);
+        if (this.logger && typeof result.checkedCount === 'number') {
+            this.logger.debug(`Transaction tree checked: ${result.checkedCount} unique transaction(s)`);
+        }
+        if (!result.success && result.error) {
+            const { txHash, exitCode, resultCode, reason, address: errorAddress, hashType } = result.error;
+            const context = reason === 'not_found'
+                ? ` address=${errorAddress ?? 'unknown'} hashType=${hashType ?? 'unknown'}`
+                : '';
+            throw (0, errors_1.txFinalizationError)(`${txHash}: reason=${reason} (exitCode=${exitCode}, resultCode=${resultCode})${context}`);
+        }
+    }
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    async trackTransactionTreeWithResult(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+        waitForRootTransaction: Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION,
+    }) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, maxScannedTransactions = Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS, direction = 'both', waitForRootTransaction = Consts_1.DEFAULT_WAIT_FOR_ROOT_TRANSACTION, } = params;
+        const parsedAddress = ton_1.Address.parse(address);
+        const normalizedRootHash = (0, Utils_1.normalizeHashToBase64)(hash);
+        const visitedSearchKeys = new Set();
+        const processedTxHashes = new Set();
+        let checkedCount = 0;
+        const searchOpts = { limit, archival: true, maxScannedTransactions };
+        const queue = [
+            { address: parsedAddress, hash: normalizedRootHash, depth: 0, hashType: 'unknown' },
+        ];
+        while (queue.length > 0) {
+            const { hash: currentHash, depth: currentDepth, address: currentAddress, hashType } = queue.shift();
+            const visitedKey = `${currentAddress.toString()}:${currentHash}:${hashType}`;
+            if (visitedSearchKeys.has(visitedKey))
+                continue;
+            visitedSearchKeys.add(visitedKey);
+            const tx = currentDepth === 0
+                ? await this.findRootTransactionWithRetry(currentAddress, currentHash, hashType, limit, maxScannedTransactions, waitForRootTransaction)
+                : await this.findTransactionByHashType(currentAddress, currentHash, hashType, searchOpts);
+            if (!tx) {
+                this.logger?.debug(`Transaction not found for hash: ${currentHash} (address=${currentAddress?.toString()}, hashType=${hashType ?? 'unknown'})`);
+                return {
+                    success: false,
+                    checkedCount,
+                    error: {
+                        txHash: currentHash,
+                        exitCode: 'N/A',
+                        resultCode: 'N/A',
+                        reason: 'not_found',
+                        address: currentAddress?.toString(),
+                        hashType: hashType ?? 'unknown',
+                    },
+                };
+            }
+            const txHash = tx.hash().toString('base64');
+            if (processedTxHashes.has(txHash)) {
+                continue;
+            }
+            processedTxHashes.add(txHash);
+            checkedCount += 1;
+            this.logger?.debug(`Checking tx (depth ${currentDepth}): ${txHash}`);
+            // Validate transaction and return error if found
+            const validationError = this.validateTransactionWithResult(tx, ignoreOpcodeList);
+            if (validationError) {
+                return { success: false, checkedCount, error: validationError };
+            }
+            // Add adjacent transactions to queue
+            if (currentDepth < maxDepth) {
+                if ((direction === 'forward' || direction === 'both') && tx.outMessages.size > 0) {
+                    for (const msg of tx.outMessages.values()) {
+                        const dst = msg.info.dest;
+                        if (!dst || dst instanceof ton_1.ExternalAddress)
+                            continue;
+                        queue.push({
+                            hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64'),
+                            address: dst,
+                            depth: currentDepth + 1,
+                            hashType: 'in',
+                        });
+                    }
+                }
+                // Backward: add parent (incoming message source)
+                if ((direction === 'backward' || direction === 'both') && tx.inMessage?.info.type === 'internal') {
+                    queue.push({
+                        hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64'),
+                        address: tx.inMessage.info.src,
+                        depth: currentDepth + 1,
+                        hashType: 'out',
+                    });
+                }
+            }
+        }
+        return { success: true, checkedCount };
+    }
+}
+exports.BaseContractOpener = BaseContractOpener;

package/dist/src/adapters/LiteClientOpener.d.ts

@@ -0,0 +1,38 @@
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ILogger } from '../interfaces';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+type LiteServer = {
+    ip: number;
+    port: number;
+    id: {
+        '@type': string;
+        key: string;
+    };
+};
+export declare class LiteClientOpener extends BaseContractOpener {
+    private readonly client;
+    private readonly engine;
+    private readonly singleEngines;
+    private isClosing;
+    private isClosed;
+    private constructor();
+    static create(options: {
+        liteservers: LiteServer[];
+    } | {
+        network: Network;
+    }, logger?: ILogger): Promise<LiteClientOpener>;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    private disableReconnect;
+    closeConnections(): void;
+    getContractState(addr: Address): Promise<ContractState>;
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(addr: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+export declare function liteClientOpener(options: {
+    liteservers: LiteServer[];
+} | {
+    network: Network;
+}, logger?: ILogger): Promise<LiteClientOpener>;
+export {};