@tonappchain/sdk 0.6.6-mainnet-alpha → 0.7.0-rc10

package/dist/sdk/StartTracking.d.ts

@@ -1,3 +1,5 @@
+import { TxFinalizerConfig } from '../structs/InternalStruct';
+import { ILogger } from '../interfaces';
 import { ExecutionStages, Network, TransactionLinker } from '../structs/Struct';
 export declare function startTracking(transactionLinker: TransactionLinker, network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -5,6 +7,8 @@ export declare function startTracking(transactionLinker: TransactionLinker, netw
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
+    txFinalizerConfig?: TxFinalizerConfig;
+    logger?: ILogger;
 }): Promise<void | ExecutionStages>;
 export declare function startTrackingMultiple(transactionLinkers: TransactionLinker[], network: Network, options?: {
     customLiteSequencerEndpoints?: string[];
@@ -12,4 +16,6 @@ export declare function startTrackingMultiple(transactionLinkers: TransactionLin
     maxIterationCount?: number;
     returnValue?: boolean;
     tableView?: boolean;
+    txFinalizerConfig?: TxFinalizerConfig;
+    logger?: ILogger;
 }): Promise<void | ExecutionStages[]>;

package/dist/sdk/StartTracking.js

@@ -5,19 +5,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startTracking = startTracking;
 exports.startTrackingMultiple = startTrackingMultiple;
+const cli_table3_1 = __importDefault(require("cli-table3"));
 const Struct_1 = require("../structs/Struct");
 const Consts_1 = require("./Consts");
+const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
+const TxFinalizer_1 = require("./TxFinalizer");
 const Utils_1 = require("./Utils");
-const cli_table3_1 = __importDefault(require("cli-table3"));
 async function startTracking(transactionLinker, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, } = options || {};
-    const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints);
-    console.log('Start tracking operation');
-    console.log('caller: ', transactionLinker.caller);
-    console.log('shardsKey: ', transactionLinker.shardsKey);
-    console.log('shardCount: ', transactionLinker.shardCount);
-    console.log('timestamp: ', transactionLinker.timestamp);
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, logger = new Logger_1.NoopLogger(), } = options || {};
+    const tracker = new OperationTracker_1.OperationTracker(network, customLiteSequencerEndpoints, logger);
+    logger.debug('Start tracking operation');
+    logger.debug('caller: ' + transactionLinker.caller);
+    logger.debug('shardsKey: ' + transactionLinker.shardsKey);
+    logger.debug('shardCount: ' + transactionLinker.shardCount);
+    logger.debug('timestamp: ' + transactionLinker.timestamp);
     let operationId = '';
     let iteration = 0; // number of iterations
     let operationType = '';
@@ -31,11 +33,13 @@ async function startTracking(transactionLinker, network, options) {
             break;
         }
         if (operationId == '') {
-            console.log('request operationId');
+            logger.debug('request operationId');
             try {
                 operationId = await tracker.getOperationId(transactionLinker);
             }
-            catch (err) { }
+            catch {
+                // Ignore error and continue
+            }
         }
         else {
             try {
@@ -45,47 +49,73 @@ async function startTracking(transactionLinker, network, options) {
                 }
             }
             catch (err) {
-                console.log('failed to get operation type:', err);
+                logger.debug('failed to get operation type: ' + err);
             }
-            console.log(`
-                operationId: ${operationId}
-                operationType: ${operationType}
-                time: ${new Date().toISOString()} (${Math.floor(+new Date() / 1000)})
+            logger.debug(`
+                operationId: ${operationId}
+                operationType: ${operationType}
+                time: ${new Date().toISOString()} (${Math.floor(+new Date() / 1000)})
             `);
         }
         await (0, Utils_1.sleep)(delay * 1000);
     }
-    console.log('Tracking finished');
+    logger.debug('Tracking finished');
     if (!ok) {
         if (returnValue) {
             throw Error(errorMessage);
         }
-        console.log(errorMessage);
+        logger.debug(errorMessage);
     }
     const profilingData = await tracker.getStageProfiling(operationId);
+    // Check if EXECUTED_IN_TON stage exists and use TxFinalizer 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 (txFinalizerConfig) {
+            const txFinalizer = new TxFinalizer_1.TonTxFinalizer(txFinalizerConfig, logger);
+            const transactions = profilingData.executedInTON.stageData.transactions;
+            for (const tx of transactions) {
+                try {
+                    logger.debug(`Verifying transaction: ${tx.hash}`);
+                    await txFinalizer.trackTransactionTree(tx.hash);
+                    logger.debug(`Transaction ${tx.hash} verified successfully in TON`);
+                }
+                catch (error) {
+                    logger.debug(`Transaction ${tx.hash} failed verification in TON: ${error}`);
+                    if (returnValue) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        else {
+            logger.debug('TxFinalizer config not provided, skipping TON transaction verification');
+        }
+    }
     if (returnValue) {
         return profilingData;
     }
-    console.log(profilingData.operationType);
-    console.log(profilingData.metaInfo);
+    logger.debug(profilingData.operationType);
+    logger.debug(profilingData.metaInfo);
     if (tableView) {
-        printExecutionStagesTable(profilingData);
+        printExecutionStagesTable(profilingData, logger);
     }
     else {
-        console.log(formatExecutionStages(profilingData));
+        logger.debug(formatExecutionStages(profilingData));
     }
 }
 async function startTrackingMultiple(transactionLinkers, network, options) {
-    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, } = options || {};
-    console.log(`Start tracking ${transactionLinkers.length} operations`);
+    const { customLiteSequencerEndpoints, delay = 10, maxIterationCount = Consts_1.MAX_ITERATION_COUNT, returnValue = false, tableView = true, txFinalizerConfig, logger = new Logger_1.NoopLogger(), } = options || {};
+    logger.debug(`Start tracking ${transactionLinkers.length} operations`);
     const results = await Promise.all(transactionLinkers.map((linker, index) => {
-        console.log(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
+        logger.debug(`\nProcessing operation ${index + 1}/${transactionLinkers.length}`);
         return startTracking(linker, network, {
             customLiteSequencerEndpoints,
             delay,
             maxIterationCount,
             returnValue: true,
             tableView: false,
+            txFinalizerConfig,
+            logger,
         });
     }));
     if (returnValue) {
@@ -93,20 +123,27 @@ async function startTrackingMultiple(transactionLinkers, network, options) {
     }
     if (tableView) {
         results.forEach((result, index) => {
-            console.log(`\nResults for operation ${index + 1}:`);
-            printExecutionStagesTable(result);
+            logger.debug(`\nResults for operation ${index + 1}:`);
+            printExecutionStagesTable(result, logger);
         });
     }
     else {
         results.forEach((result, index) => {
-            console.log(`\nResults for operation ${index + 1}:`);
-            console.log(formatExecutionStages(result));
+            logger.debug(`\nResults for operation ${index + 1}:`);
+            logger.debug(formatExecutionStages(result));
         });
     }
 }
 function formatExecutionStages(stages) {
-    const { operationType, metaInfo, ...stagesData } = stages;
-    return Object.entries(stagesData).map(([stage, data]) => ({
+    const { collectedInTAC, includedInTACConsensus, executedInTAC, collectedInTON, includedInTONConsensus, executedInTON, } = stages;
+    return Object.entries({
+        collectedInTAC,
+        includedInTACConsensus,
+        executedInTAC,
+        collectedInTON,
+        includedInTONConsensus,
+        executedInTON,
+    }).map(([stage, data]) => ({
         stage: stage,
         exists: data.exists ? 'Yes' : 'No',
         success: data.exists && data.stageData ? (data.stageData.success ? 'Yes' : 'No') : '-',
@@ -123,7 +160,7 @@ function formatExecutionStages(stages) {
         bytesError: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
     }));
 }
-function printExecutionStagesTable(stages) {
+function printExecutionStagesTable(stages, logger) {
     const table = new cli_table3_1.default({
         head: [
             'Stage',
@@ -153,5 +190,5 @@ function printExecutionStagesTable(stages) {
             row.bytesError,
         ]);
     });
-    console.log(table.toString());
+    logger.debug(table.toString());
 }

package/dist/sdk/TacSdk.d.ts

@@ -1,57 +1,40 @@
-import { mainnet, testnet } from '@tonappchain/artifacts';
 import { Wallet } from 'ethers';
-import type { SenderAbstraction } from '../sender';
-import { InternalTACParams, InternalTONParams } from '../structs/InternalStruct';
-import { AssetBridgingData, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, Network, NFTAddressType, NFTItemData, OperationIdsByShardsKey, RawAssetBridgingData, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, UserWalletBalanceExtended, WaitOptions, WithAddressNFTCollectionItem } from '../structs/Struct';
-import { OperationTracker } from './OperationTracker';
-export declare class TacSdk {
-    readonly network: Network;
-    readonly delay: number;
-    readonly artifacts: typeof testnet | typeof mainnet;
-    readonly TONParams: InternalTONParams;
-    readonly TACParams: InternalTACParams;
-    readonly liteSequencerEndpoints: string[];
-    readonly operationTracker: OperationTracker;
-    readonly debug: boolean;
+import { FT, NFT } from '../assets';
+import type { ISender } from '../sender';
+import { IAsset, CrossChainTransactionOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, NFTItemData, OperationIdsByShardsKey, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions, AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg } from '../structs/Struct';
+import { IConfiguration, ILogger, ITacSDK } from '../interfaces';
+import { JettonMasterData } from '../wrappers/JettonMaster';
+export declare class TacSdk implements ITacSDK {
+    readonly config: IConfiguration;
+    private readonly simulator;
+    private readonly transactionManager;
     private constructor();
-    static create(sdkParams: SDKParams): Promise<TacSdk>;
-    private static prepareTONParams;
-    private static prepareTACParams;
+    static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
     closeConnections(): unknown;
     get nativeTONAddress(): string;
     nativeTACAddress(): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): string[];
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: ISender, assets?: IAsset[]): Promise<ExecutionFeeEstimationResult>;
+    getTVMExecutorFeeInfo(assets: IAsset[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTONExecutorFee>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: ISender, assets?: IAsset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: ISender, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: IAsset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTransactions(sender: ISender, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    getAsset(args: AssetFromFTArg): Promise<FT>;
+    getAsset(args: AssetFromNFTCollectionArg): Promise<NFT>;
+    getAsset(args: AssetFromNFTItemArg): Promise<NFT>;
     getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
     getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
     getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
-    private getJettonTransferPayload;
-    private getJettonBurnPayload;
-    private getNFTBurnPayload;
-    private getNFTTransferPayload;
-    private getTonTransferPayload;
-    private debugLog;
-    private getJettonOpType;
-    private getNFTOpType;
-    private getNFTItemAddressTON;
-    getNFTItemData(itemAddress: string): Promise<NFTItemData>;
-    private aggregateTokens;
-    private generateJettonPayload;
-    private generateNFTPayload;
-    private generateCrossChainMessages;
-    private getRawAmount;
-    private convertAssetsToRawFormat;
-    private getFeeInfo;
-    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[]): Promise<ExecutionFeeEstimationResult>;
-    getTVMExecutorFeeInfo(assets: AssetBridgingData[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
-    private prepareCrossChainTransaction;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
-    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFTCollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
-    get getTrustedTACExecutors(): string[];
-    get getTrustedTONExecutors(): string[];
+    getJettonData(itemAddress: TVMAddress): Promise<JettonMasterData>;
+    getFT(address: TVMAddress | EVMAddress): Promise<FT>;
+    getNFTItemData(itemAddress: TVMAddress): Promise<NFTItemData>;
+    getNFT(args: AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<NFT>;
     getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
     getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
     getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
     getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
-    isContractDeployedOnTVM(address: string): Promise<boolean>;
-    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
 }