@tonappchain/sdk 0.6.1-v3.0.1 → 0.6.1-v3.0.3

package/dist/sdk/StartTracking.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTracking = startTracking;
+const Struct_1 = require("../structs/Struct");
+const Consts_1 = require("./Consts");
+const OperationTracker_1 = require("./OperationTracker");
+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);
+    let operationId = '';
+    let iteration = 0; // number of iterations
+    let operationType = '';
+    let ok = true; // finished successfully
+    let errorMessage = '';
+    while (true) {
+        ++iteration;
+        if (iteration >= maxIterationCount) {
+            ok = false;
+            errorMessage = 'maximum number of iterations has been exceeded';
+            break;
+        }
+        if (operationId == '') {
+            console.log('request operationId');
+            try {
+                operationId = await tracker.getOperationId(transactionLinker);
+            }
+            catch (err) { }
+        }
+        else {
+            try {
+                operationType = await tracker.getOperationType(operationId);
+                if (operationType != Struct_1.OperationType.PENDING && operationType != Struct_1.OperationType.UNKNOWN) {
+                    break;
+                }
+            }
+            catch (err) {
+                console.log('failed to get operation type:', err);
+            }
+            console.log(`
+                operationId: ${operationId}
+                operationType: ${operationType}
+                time: ${new Date().toISOString()} (${Math.floor(+new Date() / 1000)})
+            `);
+        }
+        await (0, Utils_1.sleep)(delay * 1000);
+    }
+    console.log('Tracking finished');
+    if (!ok) {
+        if (returnValue) {
+            throw Error(errorMessage);
+        }
+        console.log(errorMessage);
+    }
+    const profilingData = await tracker.getStageProfiling(operationId);
+    if (returnValue) {
+        return profilingData;
+    }
+    console.log(profilingData.operationType);
+    console.log(profilingData.metaInfo);
+    if (tableView) {
+        printExecutionStagesTable(profilingData);
+    }
+    else {
+        console.log(formatExecutionStages(profilingData));
+    }
+}
+function formatExecutionStages(stages) {
+    const { operationType, metaInfo, ...stagesData } = stages;
+    return Object.entries(stagesData).map(([stage, data]) => ({
+        stage: stage,
+        exists: data.exists ? 'Yes' : 'No',
+        success: data.exists && data.stageData ? (data.stageData.success ? 'Yes' : 'No') : '-',
+        timestamp: data.exists && data.stageData ? new Date(data.stageData.timestamp * 1000).toLocaleString() : '-',
+        transactions: data.exists &&
+            data.stageData &&
+            data.stageData.transactions != null &&
+            data.stageData.transactions.length > 0
+            ? data.stageData.transactions.map((t) => t.hash).join(' \n')
+            : '-',
+        noteContent: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.content : '-',
+        errorName: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.errorName : '-',
+        internalMsg: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalMsg : '-',
+        bytesError: data.exists && data.stageData && data.stageData.note != null ? data.stageData.note.internalBytesError : '-',
+    }));
+}
+function printExecutionStagesTable(stages) {
+    const table = new cli_table3_1.default({
+        head: [
+            'Stage',
+            'Exists',
+            'Success',
+            'Timestamp',
+            'Transactions',
+            'NoteContent',
+            'ErrorName',
+            'InternalMsg',
+            'BytesError',
+        ],
+        colWidths: [30, 8, 9, 13, 70, 13, 13, 13, 13],
+        wordWrap: true,
+    });
+    const tableData = formatExecutionStages(stages);
+    tableData.forEach((row) => {
+        table.push([
+            row.stage,
+            row.exists,
+            row.success,
+            row.timestamp,
+            row.transactions,
+            row.noteContent,
+            row.errorName,
+            row.internalMsg,
+            row.bytesError,
+        ]);
+    });
+    console.log(table.toString());
+}

package/dist/sdk/TacSdk.d.ts

@@ -0,0 +1,53 @@
+import { Wallet } from 'ethers';
+import type { SenderAbstraction } from '../sender';
+import { AssetBridgingData, EvmProxyMsg, Network, SDKParams, TransactionLinker, RawAssetBridgingData, UserWalletBalanceExtended, TACSimulationResult, TACSimulationRequest, CrossChainTransactionOptions, ExecutionFeeEstimationResult, CrosschainTx, WithAddressNFT_CollectionItem, NFTAddressType, NFTItemData } from '../structs/Struct';
+import { InternalTONParams, InternalTACParams } from '../structs/InternalStruct';
+import { mainnet, testnet } from '@tonappchain/artifacts';
+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[];
+    private constructor();
+    static create(sdkParams: SDKParams): Promise<TacSdk>;
+    private static prepareTONParams;
+    private static prepareTACParams;
+    closeConnections(): unknown;
+    get nativeTONAddress(): string;
+    nativeTACAddress(): Promise<string>;
+    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 generateFeeData;
+    private getTonTransferPayload;
+    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>;
+    private prepareCrossChainTransaction;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetBridgingData[], options?: CrossChainTransactionOptions): Promise<TransactionLinker>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TransactionLinker[]>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: RawAssetBridgingData<WithAddressNFT_CollectionItem>[], tvmExecutorFee?: bigint): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): string[];
+    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    getTVMNFTAddress(evmNFTAddress: string, tokenId?: bigint): Promise<string>;
+    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+}