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

package/dist/src/sdk/StartTracking.js

@@ -9,7 +9,7 @@ const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 const Utils_1 = require("./Utils");
 async function startTracking(transactionLinker, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), txFinalizer, cclAddress, } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, logger = new Logger_1.NoopLogger(), contractOpener, cclAddress, } = options || {};
     const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
     logger.debug(`Start tracking operation\n` +
         `caller: ${transactionLinker.caller}\n` +
@@ -63,15 +63,15 @@ async function startTracking(transactionLinker, network, options) {
         logger.debug(errorMessage);
     }
     const profilingData = await tracker.getStageProfiling(operationId);
-    // Check if EXECUTED_IN_TON stage exists and use TxFinalizer to verify transaction success
+    // Check if EXECUTED_IN_TON stage exists and use ContractOpener to verify transaction success
     if (profilingData.executedInTON.exists && profilingData.executedInTON.stageData?.transactions) {
         logger.debug('EXECUTED_IN_TON stage found, verifying transaction success in TON...');
-        if (txFinalizer && cclAddress) {
+        if (contractOpener && cclAddress) {
             const transactions = profilingData.executedInTON.stageData.transactions;
             for (const tx of transactions) {
                 try {
                     logger.debug(`Verifying transaction: ${tx.hash}`);
-                    await txFinalizer.trackTransactionTree(cclAddress, tx.hash, { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH });
+                    await contractOpener.trackTransactionTree(cclAddress, tx.hash, { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH });
                     logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
                 }
                 catch (error) {
@@ -83,7 +83,7 @@ async function startTracking(transactionLinker, network, options) {
             }
         }
         else {
-            logger.debug('TxFinalizer or CCL address is not provided, skipping TON transaction verification');
+            logger.debug('ContractOpener or CCL address is not provided, skipping TON transaction verification');
         }
     }
     if (returnValue) {
@@ -99,7 +99,7 @@ async function startTracking(transactionLinker, network, options) {
     }
 }
 async function startTrackingMultiple(transactionLinkers, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizer, logger = new Logger_1.NoopLogger(), } = options || {};
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, contractOpener, logger = new Logger_1.NoopLogger(), } = options || {};
     logger.debug(`Start tracking ${transactionLinkers.length} operations`);
     const results = await Promise.all(transactionLinkers.map((linker, index) => {
         logger.debug(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
@@ -109,7 +109,7 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
             maxIterationCount,
             returnValue: true,
             tableView: false,
-            txFinalizer,
+            contractOpener,
             logger,
         });
     }));

package/dist/src/sdk/TONTransactionManager.d.ts

@@ -1,5 +1,4 @@
 import { Asset, IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { type SenderAbstraction } from '../sender';
 import { BatchCrossChainTx, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
 export declare class TONTransactionManager implements ITONTransactionManager {
@@ -7,8 +6,7 @@ export declare class TONTransactionManager implements ITONTransactionManager {
     private readonly simulator;
     private readonly operationTracker;
     private readonly logger;
-    private readonly txFinalizer;
-    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger: ILogger | undefined, txFinalizer: ITxFinalizer);
+    constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
     buildFeeParams(options: CrossChainTransactionOptions, evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<FeeParams>;
     private prepareCrossChainTransaction;
     private generateCrossChainMessages;

package/dist/src/sdk/TONTransactionManager.js

@@ -11,12 +11,11 @@ const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
 const Validator_1 = require("./Validator");
 class TONTransactionManager {
-    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger(), txFinalizer) {
+    constructor(config, simulator, operationTracker, logger = new Logger_1.NoopLogger()) {
         this.config = config;
         this.simulator = simulator;
         this.operationTracker = operationTracker;
         this.logger = logger;
-        this.txFinalizer = txFinalizer;
     }
     async buildFeeParams(options, evmProxyMsg, sender, tx) {
         const { withoutSimulation, protocolFee, evmExecutorFee, tvmExecutorFee, isRoundTrip } = options;
@@ -175,7 +174,7 @@ class TONTransactionManager {
         if (waitOptions.ensureTxExecuted && sendTransactionResult.boc) {
             const hash = (0, Utils_1.getNormalizedExtMessageHash)((0, ton_1.loadMessage)(ton_1.Cell.fromBase64(sendTransactionResult.boc).beginParse()));
             this.logger.info(`Tracking transaction tree for hash: ${hash}`);
-            await this.txFinalizer.trackTransactionTree(sender.getSenderAddress(), hash, {
+            await this.config.TONParams.contractOpener.trackTransactionTree(sender.getSenderAddress(), hash, {
                 maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
             });
             this.logger.info(`Transaction tree successful`);

package/dist/src/sdk/TacSdk.d.ts

@@ -1,11 +1,12 @@
 import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
-import { IConfiguration, ILogger, IOperationTracker, ITacExplorerClient, ITacSDK } from '../interfaces';
+import { ContractOpener, IConfiguration, ILogger, IOperationTracker, ITacExplorerClient, ITacSDK } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
 import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
+    readonly contactOpener: ContractOpener;
     readonly operationTracker: IOperationTracker;
     readonly explorerClient: ITacExplorerClient;
     private readonly simulator;
@@ -45,4 +46,5 @@ export declare class TacSdk implements ITacSDK {
     getTacExplorerClient(): ITacExplorerClient;
     prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
     getTACGasPrice(): Promise<TacGasPrice>;
+    getTonContractOpener(): ContractOpener;
 }

package/dist/src/sdk/TacSdk.js

@@ -12,11 +12,11 @@ const Simulator_1 = require("./Simulator");
 const TacExplorerClient_1 = require("./TacExplorerClient");
 const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
-const TxFinalizer_1 = require("./TxFinalizer");
 const Utils_1 = require("./Utils");
 class TacSdk {
     constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
         this.config = config;
+        this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
         this.tonTransactionManager = tonTransactionManager;
         this.tacTransactionManager = tacTransactionManager;
@@ -44,8 +44,7 @@ class TacSdk {
         const operationTracker = new OperationTracker_1.OperationTracker(network, config.liteSequencerEndpoints);
         const explorerClient = new TacExplorerClient_1.TacExplorerClient(artifacts.TAC_EXPLORER_API_ENDPOINT);
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
-        const txFinalizer = sdkParams.TONParams?.txFinalizer ?? new TxFinalizer_1.TonTxFinalizer(config.TONParams.contractOpener, logger);
-        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger, txFinalizer);
+        const tonTransactionManager = new TONTransactionManager_1.TONTransactionManager(config, simulator, operationTracker, logger);
         const tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
         return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
     }
@@ -197,5 +196,8 @@ class TacSdk {
             slow: response.gasPrices.slow,
         };
     }
+    getTonContractOpener() {
+        return this.contactOpener;
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/src/sdk/TxFinalizer.d.ts

@@ -1,15 +1,8 @@
-import { ContractOpener, IHttpClient, ILogger } from '../interfaces';
+import { IHttpClient, ILogger } from '../interfaces';
 import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { TxFinalizerConfig } from '../structs/InternalStruct';
 import { TrackTransactionTreeParams } from '../structs/Struct';
 export declare class TonTxFinalizer implements ITxFinalizer {
-    private logger;
-    private contractOpener;
-    constructor(contractOpener: ContractOpener, logger?: ILogger);
-    private fetchAdjacentTransactions;
-    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
-}
-export declare class TonIndexerTxFinalizer implements ITxFinalizer {
     private logger;
     private apiConfig;
     private readonly httpClient;

package/dist/src/sdk/TxFinalizer.js

@@ -1,133 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TonIndexerTxFinalizer = exports.TonTxFinalizer = void 0;
-const ton_1 = require("@ton/ton");
+exports.TonTxFinalizer = void 0;
 const errors_1 = require("../errors");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
-const IGNORE_OPCODE = [
-    0xd53276db, // Excess
-];
 class TonTxFinalizer {
-    constructor(contractOpener, logger = new Logger_1.NoopLogger()) {
-        this.contractOpener = contractOpener;
-        this.logger = logger;
-    }
-    // Fetches adjacent transactions from toncenter
-    async fetchAdjacentTransactions(address, hash, retries = 5, delay = 1000, opts) {
-        for (let i = retries; i >= 0; i--) {
-            try {
-                const txs = await this.contractOpener.getAdjacentTransactions(address, hash, opts);
-                return txs;
-            }
-            catch (error) {
-                const errorMessage = error.message;
-                // Rate limit error (429) - retry
-                if (errorMessage.includes('429')) {
-                    if (i > 0) {
-                        await (0, Utils_1.sleep)(delay);
-                    }
-                    continue;
-                }
-                // Log all errors except 404 Not Found
-                if (!errorMessage.includes('404')) {
-                    const logMessage = error instanceof Error ? error.message : error;
-                    this.logger.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
-                }
-                if (i > 0) {
-                    await (0, Utils_1.sleep)(delay);
-                }
-            }
-        }
-        return [];
-    }
-    // Checks if all transactions in the tree are successful
-    async trackTransactionTree(address, hash, params = { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList: IGNORE_OPCODE }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = IGNORE_OPCODE } = params;
-        const parsedAddress = ton_1.Address.parse(address);
-        const visitedHashes = new Set();
-        const queue = [{ address: parsedAddress, hash, depth: 0 }];
-        while (queue.length > 0) {
-            const { hash: currentHash, depth: currentDepth, address: currentAddress } = queue.shift();
-            if (visitedHashes.has(currentHash)) {
-                continue;
-            }
-            visitedHashes.add(currentHash);
-            this.logger.debug(`Checking hash (depth ${currentDepth}): ${currentHash}`);
-            const transactions = await this.fetchAdjacentTransactions(currentAddress, currentHash, 5, 1000, {
-                limit: 10,
-                archival: true,
-            });
-            this.logger.debug(`Found ${transactions.length} adjacent transactions for ${currentHash}`);
-            if (transactions.length === 0)
-                continue;
-            for (const tx of transactions) {
-                if (tx.description.type !== 'generic' || !tx.inMessage)
-                    continue;
-                if (tx.inMessage.info.type === 'internal' && tx.inMessage.info.value.coins === Consts_1.IGNORE_MSG_VALUE_1_NANO)
-                    continue; // we ignore messages with 1 nanoton value as they are for notification purpose only
-                const bodySlice = tx.inMessage.body.beginParse();
-                if (bodySlice.remainingBits < 32)
-                    continue;
-                const opcode = bodySlice.loadUint(32);
-                if (!ignoreOpcodeList.includes(opcode)) {
-                    const { aborted, computePhase, actionPhase } = tx.description;
-                    const failureCase = (() => {
-                        if (aborted) {
-                            return 'Transaction was aborted';
-                        }
-                        if (!computePhase) {
-                            return 'computePhase not present';
-                        }
-                        if (computePhase.type === 'skipped') {
-                            return 'computePhase was skipped';
-                        }
-                        if (!computePhase.success) {
-                            return 'computePhase not successful';
-                        }
-                        if (computePhase.exitCode !== 0) {
-                            return `computePhase.exitCode was not zero (exitCode=${computePhase.exitCode})`;
-                        }
-                        if (actionPhase && !actionPhase.success) {
-                            return 'actionPhase not successful';
-                        }
-                        if (actionPhase && actionPhase.resultCode !== 0) {
-                            return `actionPhase.resultCode was not zero (resultCode=${actionPhase.resultCode})`;
-                        }
-                        return null;
-                    })();
-                    if (failureCase) {
-                        throw (0, errors_1.txFinalizationError)(`${tx.hash().toString('base64')}: ${failureCase}`);
-                    }
-                    if (currentDepth + 1 < maxDepth) {
-                        if (tx.outMessages.size > 0) {
-                            queue.push({
-                                hash: tx.hash().toString('base64'),
-                                address: tx.inMessage.info.dest,
-                                depth: currentDepth + 1,
-                            });
-                        }
-                    }
-                }
-                else {
-                    this.logger.debug(`Skipping hash (depth ${currentDepth}): ${tx.hash().toString('base64')}`);
-                }
-            }
-            this.logger.debug(`Finished checking hash (depth ${currentDepth}): ${currentHash}`);
-        }
-    }
-}
-exports.TonTxFinalizer = TonTxFinalizer;
-class TonIndexerTxFinalizer {
     constructor(apiConfig, logger = new Logger_1.NoopLogger(), httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
         this.apiConfig = apiConfig;
         this.logger = logger;
         this.httpClient = httpClient;
     }
     // Fetches adjacent transactions from toncenter
-    async fetchAdjacentTransactions(hash, retries = 5, delay = 1000) {
+    async fetchAdjacentTransactions(hash, retries = Consts_1.DEFAULT_RETRY_MAX_COUNT, delay = Consts_1.DEFAULT_RETRY_DELAY_MS) {
         for (let i = retries; i >= 0; i--) {
             try {
                 const url = this.apiConfig.urlBuilder(hash);
@@ -161,8 +47,8 @@ class TonIndexerTxFinalizer {
         return [];
     }
     // Checks if all transactions in the tree are successful
-    async trackTransactionTree(_, hash, params = { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList: IGNORE_OPCODE }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = IGNORE_OPCODE } = params;
+    async trackTransactionTree(_, hash, params = { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList: Consts_1.IGNORE_OPCODE }) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE } = params;
         const visitedHashes = new Set();
         const queue = [{ hash, depth: 0 }];
         while (queue.length > 0) {
@@ -191,18 +77,20 @@ class TonIndexerTxFinalizer {
                             return 'computePh not successful';
                         }
                         if (computePh.exitCode !== 0) {
-                            return `computePh.exitCode was not zero (exitCode=${computePh.exitCode})`;
+                            return `computePh.exitCode was not zero`;
                         }
                         if (action && !action.success) {
                             return 'action not successful';
                         }
                         if (action && action.resultCode !== 0) {
-                            return `action.resultCode was not zero (resultCode=${action.resultCode})`;
+                            return `action.resultCode was not zero`;
                         }
                         return null;
                     })();
                     if (failureCase) {
-                        throw (0, errors_1.txFinalizationError)(`${tx.hash}: ${failureCase}`);
+                        const exitCode = computePh ? computePh.exitCode : 'N/A';
+                        const resultCode = action ? action.resultCode : 'N/A';
+                        throw (0, errors_1.txFinalizationError)(`${tx.hash}: ${failureCase} (exitCode=${exitCode}, resultCode=${resultCode})`);
                     }
                     if (currentDepth + 1 < maxDepth) {
                         if (tx.outMsgs.length > 0) {
@@ -217,4 +105,4 @@ class TonIndexerTxFinalizer {
         }
     }
 }
-exports.TonIndexerTxFinalizer = TonIndexerTxFinalizer;
+exports.TonTxFinalizer = TonTxFinalizer;

package/dist/src/sdk/Utils.d.ts

@@ -37,6 +37,11 @@ export declare function getString(cell?: Cell): string;
  * Calculates (a * b + c / 2) / c with proper rounding
  */
 export declare function muldivr(a: bigint, b: bigint, c: bigint): bigint;
+/**
+ * Normalize hash string to base64 format
+ * Accepts: base64, hex, or raw string
+ */
+export declare function normalizeHashToBase64(hash: string): string;
 export declare function getNormalizedExtMessageHash(message: Message): string;
 export declare function retry<T>(fn: () => Promise<T>, options: {
     retries: number;

package/dist/src/sdk/Utils.js

@@ -20,6 +20,7 @@ exports.getAddressString = getAddressString;
 exports.getNumber = getNumber;
 exports.getString = getString;
 exports.muldivr = muldivr;
+exports.normalizeHashToBase64 = normalizeHashToBase64;
 exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
 exports.retry = retry;
 exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
@@ -316,6 +317,29 @@ function muldivr(a, b, c) {
     }
     return (a * b + c / 2n) / c;
 }
+/**
+ * Normalize hash string to base64 format
+ * Accepts: base64, hex, or raw string
+ */
+function normalizeHashToBase64(hash) {
+    // If already base64 (contains +, /, = or matches base64 pattern)
+    if (/^[A-Za-z0-9+/]+={0,2}$/.test(hash)) {
+        try {
+            // Validate it's valid base64
+            Buffer.from(hash, 'base64');
+            return hash;
+        }
+        catch {
+            // Fall through to hex conversion
+        }
+    }
+    // Try as hex
+    if (/^[0-9a-fA-F]+$/.test(hash)) {
+        return Buffer.from(hash, 'hex').toString('base64');
+    }
+    // Assume it's already base64
+    return hash;
+}
 function getNormalizedExtMessageHash(message) {
     if (message.info.type !== 'external-in') {
         throw new Error(`Message must be "external-in", got ${message.info.type}`);

package/dist/src/structs/InternalStruct.d.ts

@@ -99,6 +99,7 @@ export type TransactionDepth = {
     address?: Address;
     hash: string;
     depth: number;
+    hashType?: 'unknown' | 'in' | 'out';
 };
 export type AdjacentTransactionsResponse = {
     transactions: ToncenterTransaction[];
@@ -123,22 +124,6 @@ export type ConvertedCurrencyRawResult = {
     tacPrice: USDPriceInfoRaw;
     tonPrice: USDPriceInfoRaw;
 };
-export type GetTransactionsOptions = {
-    limit: number;
-    lt?: string;
-    hash?: string;
-    to_lt?: string;
-    inclusive?: boolean;
-    archival?: boolean;
-    timeoutMs?: number;
-    retryDelayMs?: number;
-};
-export type AddressInformation = {
-    lastTransaction: {
-        lt: string;
-        hash: string;
-    };
-};
 export type TONFeesParams = {
     accountBitPrice: number;
     accountCellPrice: number;

package/dist/src/structs/Struct.d.ts

@@ -4,7 +4,6 @@ import { AbstractProvider } from 'ethers';
 import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
 import type { FT, NFT } from '../assets';
 import type { Asset, ContractOpener, ILogger } from '../interfaces';
-import { ITxFinalizer } from '../interfaces/ITxFinalizer';
 import { SendResult } from './InternalStruct';
 export type ContractState = {
     balance: bigint;
@@ -61,10 +60,6 @@ export type TONParams = {
      * Address of TON settings contract. Use only for tests.
      */
     settingsAddress?: string;
-    /**
-     * TxFinalizer for tracking transaction tree
-     */
-    txFinalizer?: ITxFinalizer;
 };
 export type SDKParams = {
     /**
@@ -451,7 +446,97 @@ export type TacGasPrice = {
     fast: number;
     slow: number;
 };
+/**
+ * Parameters for tracking and validating transaction trees
+ */
 export type TrackTransactionTreeParams = {
+    /**
+     * Maximum number of transactions to fetch per pagination request
+     * @default 100
+     */
+    limit?: number;
+    /**
+     * Maximum depth to traverse in the transaction tree (prevents infinite loops)
+     * @default 10
+     */
     maxDepth?: number;
+    /**
+     * List of operation codes (opcodes) to skip during validation.
+     * Transactions with these opcodes in their incoming message will not be validated.
+     * @default [ 0xd53276db ] // Excess
+     */
     ignoreOpcodeList?: number[];
+    /**
+     * Direction to search the transaction tree:
+     * - 'forward': only search children (outgoing messages)
+     * - 'backward': only search parents (incoming messages)
+     * - 'both': search in both directions (default)
+     * @default 'both'
+     */
+    direction?: 'forward' | 'backward' | 'both';
+};
+/**
+ * Details about a transaction validation error
+ */
+export type TransactionValidationError = {
+    /**
+     * Base64-encoded hash of the failed transaction
+     */
+    txHash: string;
+    /**
+     * Exit code from the compute phase, or 'N/A' if compute phase is missing
+     */
+    exitCode: number | 'N/A';
+    /**
+     * Result code from the action phase, or 'N/A' if action phase is missing
+     */
+    resultCode: number | 'N/A';
+    /**
+     * Reason for validation failure:
+     * - 'aborted': default: transaction was aborted
+     * - 'compute_phase_missing': compute phase is missing or skipped
+     * - 'compute_phase_failed': compute phase failed (exitCode !== 0)
+     * - 'action_phase_failed': action phase failed (resultCode !== 0)
+     */
+    reason: 'aborted' | 'compute_phase_missing' | 'compute_phase_failed' | 'action_phase_failed';
+};
+/**
+ * Result of transaction tree tracking and validation
+ */
+export type TrackTransactionTreeResult = {
+    /**
+     * Whether all transactions in the tree passed validation
+     */
+    success: boolean;
+    /**
+     * Details about the first validation error encountered (if any)
+     */
+    error?: TransactionValidationError;
+};
+export type GetTransactionsOptions = {
+    /** Maximum number of transactions to retrieve */
+    limit?: number;
+    /** Logical time of the transaction to start from */
+    lt?: string;
+    /** Hash of the transaction to start from */
+    hash?: string;
+    /** Logical time of the transaction to end at */
+    to_lt?: string;
+    /** Whether to include the starting transaction in the results */
+    inclusive?: boolean;
+    /** Whether to search in archival nodes for historical data */
+    archival?: boolean;
+    /** Request timeout in milliseconds */
+    timeoutMs?: number;
+    /** Delay between retry attempts in milliseconds */
+    retryDelayMs?: number;
+};
+export type AddressInformation = {
+    /** Information about the last transaction of the address */
+    lastTransaction: {
+        /** Logical time of the last transaction */
+        lt: string;
+        /** Hash of the last transaction */
+        hash: string;
+    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tonappchain/sdk",
-    "version": "0.7.2-alpha-11",
+    "version": "0.7.2-alpha-13",
     "repository": "https://github.com/TacBuild/tac-sdk.git",
     "author": "TAC. <developers@tac>",
     "license": "MIT",

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

@@ -1,24 +0,0 @@
-import { Blockchain } from '@ton/sandbox';
-import { Address, TonClient, Transaction } from '@ton/ton';
-import { ContractOpener } from '../interfaces';
-import { GetTransactionsOptions } from '../structs/InternalStruct';
-import { Network } from '../structs/Struct';
-export declare function getAdjacentTransactionsHelper(addr: Address, hashB64: string, getTransactions: (addr: Address, opts: GetTransactionsOptions) => Promise<Transaction[]>, opts?: GetTransactionsOptions): Promise<Transaction[]>;
-type LiteServer = {
-    ip: number;
-    port: number;
-    id: {
-        '@type': string;
-        key: string;
-    };
-};
-export declare function liteClientOpener(options: {
-    liteservers: LiteServer[];
-} | {
-    network: Network;
-}): Promise<ContractOpener>;
-export declare function sandboxOpener(blockchain: Blockchain): ContractOpener;
-export declare function orbsOpener(network: Network): Promise<ContractOpener>;
-export declare function orbsOpener4(network: Network, timeout?: number): Promise<ContractOpener>;
-export declare function tonClientOpener(client: TonClient): ContractOpener;
-export {};