@tonappchain/sdk 0.7.2-alpha-7 → 0.7.2-alpha-10

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

@@ -0,0 +1,8 @@
+import { IHttpClient, ITacExplorerClient } from '../interfaces';
+import { TacGasPriceResponse } from '../structs/InternalStruct';
+export declare class TacExplorerClient implements ITacExplorerClient {
+    private readonly explorerApiEndpoint;
+    private readonly httpClient;
+    constructor(explorerApiEndpoint: string, httpClient?: IHttpClient);
+    getTACGasPrice(): Promise<TacGasPriceResponse>;
+}

package/dist/src/sdk/TacExplorerClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TacExplorerClient = void 0;
+const instances_1 = require("../errors/instances");
+const AxiosHttpClient_1 = require("./AxiosHttpClient");
+const Utils_1 = require("./Utils");
+class TacExplorerClient {
+    constructor(explorerApiEndpoint, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+        this.explorerApiEndpoint = explorerApiEndpoint;
+        this.httpClient = httpClient;
+    }
+    async getTACGasPrice() {
+        try {
+            const response = await this.httpClient.get(new URL('stats', this.explorerApiEndpoint).toString(), { transformResponse: [Utils_1.toCamelCaseTransformer] });
+            return response.data;
+        }
+        catch (error) {
+            throw (0, instances_1.gasPriceFetchError)(`endpoint ${this.explorerApiEndpoint} failed to complete request`, error);
+        }
+    }
+}
+exports.TacExplorerClient = TacExplorerClient;

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

@@ -1,12 +1,13 @@
 import { Wallet } from 'ethers';
 import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
-import { IConfiguration, ILogger, IOperationTracker, ITacSDK } from '../interfaces';
+import { 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, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+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 operationTracker: IOperationTracker;
+    readonly explorerClient: ITacExplorerClient;
     private readonly simulator;
     private readonly tonTransactionManager;
     private readonly tacTransactionManager;
@@ -41,10 +42,7 @@ export declare class TacSdk implements ITacSDK {
     getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
     getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
     getOperationTracker(): IOperationTracker;
+    getTacExplorerClient(): ITacExplorerClient;
     prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
-    getTACGasPrice(): Promise<{
-        average: number;
-        fast: number;
-        slow: number;
-    }>;
+    getTACGasPrice(): Promise<TacGasPrice>;
 }

package/dist/src/sdk/TacSdk.js

@@ -9,17 +9,19 @@ const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const OperationTracker_1 = require("./OperationTracker");
 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) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
         this.config = config;
         this.simulator = simulator;
         this.tonTransactionManager = tonTransactionManager;
         this.tacTransactionManager = tacTransactionManager;
         this.operationTracker = operationTracker;
+        this.explorerClient = explorerClient;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
@@ -38,13 +40,14 @@ class TacSdk {
             default:
                 throw new Error(`Unsupported network: ${network}`);
         }
-        const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay);
+        const config = await Configuration_1.Configuration.create(network, artifacts, sdkParams.TONParams, sdkParams.TACParams, sdkParams.customLiteSequencerEndpoints, delay, logger);
         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 tacTransactionManager = new TACTransactionManager_1.TACTransactionManager(config, operationTracker, logger);
-        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -179,12 +182,15 @@ class TacSdk {
     getOperationTracker() {
         return this.operationTracker;
     }
+    getTacExplorerClient() {
+        return this.explorerClient;
+    }
     async prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, assets = [], options) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
         return this.tonTransactionManager.prepareCrossChainTransactionPayload(evmProxyMsg, senderAddress, normalizedAssets, options);
     }
     async getTACGasPrice() {
-        const response = await this.operationTracker.getTACGasPrice();
+        const response = await this.explorerClient.getTACGasPrice();
         return {
             average: response.gasPrices.average,
             fast: response.gasPrices.fast,

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

@@ -1,14 +1,13 @@
 import { ContractOpener, 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?: {
-        maxDepth?: number;
-    }): Promise<void>;
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
 }
 export declare class TonIndexerTxFinalizer implements ITxFinalizer {
     private logger;
@@ -16,7 +15,5 @@ export declare class TonIndexerTxFinalizer implements ITxFinalizer {
     private readonly httpClient;
     constructor(apiConfig: TxFinalizerConfig, logger?: ILogger, httpClient?: IHttpClient);
     private fetchAdjacentTransactions;
-    trackTransactionTree(_: string, hash: string, params?: {
-        maxDepth?: number;
-    }): Promise<void>;
+    trackTransactionTree(_: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
 }

package/dist/src/sdk/TxFinalizer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonIndexerTxFinalizer = exports.TonTxFinalizer = void 0;
 const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
 const AxiosHttpClient_1 = require("./AxiosHttpClient");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
@@ -43,8 +44,8 @@ class TonTxFinalizer {
         return [];
     }
     // Checks if all transactions in the tree are successful
-    async trackTransactionTree(address, hash, params = { maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH } = params;
+    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 }];
@@ -71,18 +72,34 @@ class TonTxFinalizer {
                 if (bodySlice.remainingBits < 32)
                     continue;
                 const opcode = bodySlice.loadUint(32);
-                if (!IGNORE_OPCODE.includes(opcode)) {
+                if (!ignoreOpcodeList.includes(opcode)) {
                     const { aborted, computePhase, actionPhase } = tx.description;
-                    if (aborted ||
-                        computePhase.type == 'skipped' ||
-                        !computePhase.success ||
-                        computePhase.exitCode !== 0 ||
-                        (actionPhase && (!actionPhase.success || actionPhase.resultCode !== 0))) {
-                        throw new Error(`Transaction failed:\n` +
-                            `hash = ${currentHash}, ` +
-                            `aborted = ${aborted}, ` +
-                            `compute phase: ${computePhase.type === 'skipped' ? 'skipped' : `success = ${computePhase.success}, exit code = ${computePhase.exitCode}`}, ` +
-                            `action phase: ${!actionPhase ? 'skipped' : `success = ${actionPhase.success}, result code = ${actionPhase.resultCode}`} `);
+                    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) {
@@ -144,8 +161,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 }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH } = params;
+    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;
         const visitedHashes = new Set();
         const queue = [{ hash, depth: 0 }];
         while (queue.length > 0) {
@@ -161,38 +178,31 @@ class TonIndexerTxFinalizer {
             for (const tx of transactions) {
                 if (tx.inMsg.value === Consts_1.IGNORE_MSG_VALUE_1_NANO.toString())
                     continue; // we ignore messages with 1 nanoton value as they are for notification purpose only
-                if (!IGNORE_OPCODE.includes(Number(tx.inMsg.opcode)) && tx.inMsg.opcode !== null) {
+                if (!ignoreOpcodeList.includes(Number(tx.inMsg.opcode)) && tx.inMsg.opcode !== null) {
                     const { aborted, computePh, action } = tx.description;
                     const failureCase = (() => {
-                        switch (true) {
-                            case aborted:
-                                return 'Transaction was aborted';
-                            case !computePh:
-                                return 'computePh not present';
-                            case !computePh.success:
-                                return 'computePh not successful';
-                            case !action:
-                                return 'action not present';
-                            case !action.success:
-                                return 'action not successful';
-                            case computePh.exitCode !== 0:
-                                return `computePh.exitCode was not zero (exitCode=${computePh.exitCode})`;
-                            case action.resultCode !== 0:
-                                return `action.resultCode was not zero (resultCode=${action.resultCode})`;
-                            default:
-                                return null;
+                        if (aborted) {
+                            return 'Transaction was aborted';
+                        }
+                        if (!computePh) {
+                            return 'computePh not present';
+                        }
+                        if (!computePh.success) {
+                            return 'computePh not successful';
+                        }
+                        if (computePh.exitCode !== 0) {
+                            return `computePh.exitCode was not zero (exitCode=${computePh.exitCode})`;
+                        }
+                        if (action && !action.success) {
+                            return 'action not successful';
+                        }
+                        if (action && action.resultCode !== 0) {
+                            return `action.resultCode was not zero (resultCode=${action.resultCode})`;
                         }
+                        return null;
                     })();
                     if (failureCase) {
-                        throw new Error(`Transaction failed [${failureCase}]:\n` +
-                            `hash = ${currentHash}, ` +
-                            `aborted = ${aborted}, ` +
-                            `computePh = ${computePh}, ` +
-                            `action = ${action}, ` +
-                            `computePh.success = ${computePh?.success}, ` +
-                            `computePh.exitCode = ${computePh?.exitCode}, ` +
-                            `action.success = ${action?.success}, ` +
-                            `action.resultCode = ${action?.resultCode}`);
+                        throw (0, errors_1.txFinalizationError)(`${tx.hash}: ${failureCase}`);
                     }
                     if (currentDepth + 1 < maxDepth) {
                         if (tx.outMsgs.length > 0) {

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

@@ -32,6 +32,11 @@ export declare function normalizeAssets(config: IConfiguration, assets?: AssetLi
 export declare function getAddressString(cell?: Cell): string;
 export declare function getNumber(len: number, cell?: Cell): number;
 export declare function getString(cell?: Cell): string;
+/**
+ * Multiply-divide with rounding (muldivr)
+ * Calculates (a * b + c / 2) / c with proper rounding
+ */
+export declare function muldivr(a: bigint, b: bigint, c: bigint): bigint;
 export declare function getNormalizedExtMessageHash(message: Message): string;
 export declare function retry<T>(fn: () => Promise<T>, options: {
     retries: number;

package/dist/src/sdk/Utils.js

@@ -19,6 +19,7 @@ exports.normalizeAssets = normalizeAssets;
 exports.getAddressString = getAddressString;
 exports.getNumber = getNumber;
 exports.getString = getString;
+exports.muldivr = muldivr;
 exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
 exports.retry = retry;
 exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
@@ -305,6 +306,16 @@ function getNumber(len, cell) {
 function getString(cell) {
     return cell?.beginParse().loadStringTail() ?? '';
 }
+/**
+ * Multiply-divide with rounding (muldivr)
+ * Calculates (a * b + c / 2) / c with proper rounding
+ */
+function muldivr(a, b, c) {
+    if (c === 0n) {
+        throw new Error('Division by zero in muldivr');
+    }
+    return (a * b + c / 2n) / c;
+}
 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

@@ -37,6 +37,7 @@ export type InternalTONParams = {
     nftItemCode: Cell;
     nftCollectionCode: Cell;
     feesParams: TONFeesParams;
+    contractFeeUsageParams: ContractFeeUsageParams;
 };
 export type InternalTACParams = {
     provider: AbstractProvider;
@@ -148,6 +149,64 @@ export type TONFeesParams = {
     msgBitPrice: number;
     msgCellPrice: number;
 };
+export type ContractFeeUsageParams = {
+    crossChainLayer: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            tvmMsgToEvm: number;
+        };
+    };
+    jettonWallet: {
+        accountBits: number;
+        accountCells: number;
+        estimatedAccountBits: number;
+        estimatedAccountCells: number;
+        initStateBits: number;
+        initStateCells: number;
+        gas: {
+            internalTransfer: number;
+            receive: number;
+            burn: number;
+            estimatedSendTransfer: number;
+            estimatedReceiveTransfer: number;
+        };
+    };
+    jettonProxy: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+            transferNotification: number;
+            errorNotification: number;
+        };
+    };
+    jettonMinter: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            burnNotification: number;
+            mintAfterError: number;
+        };
+    };
+    nftItem: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            send: number;
+            burn: number;
+            errorNotification: number;
+        };
+    };
+    nftProxy: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+            errorNotification: number;
+        };
+    };
+};
 export type TransactionFeeCalculationStep = {
     accountBits: number;
     accountCells: number;
@@ -157,3 +216,10 @@ export type TransactionFeeCalculationStep = {
     timeDelta: number;
 };
 export type TONFeeCalculationParams = TransactionFeeCalculationStep & TONFeesParams;
+export type TacGasPriceResponse = {
+    gasPrices: {
+        average: number;
+        fast: number;
+        slow: number;
+    };
+};

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

@@ -446,10 +446,12 @@ export type GeneratePayloadParams = {
     forwardFeeTonAmount?: bigint;
     feeParams?: FeeParams;
 };
-export type TacGasPriceResponse = {
-    gasPrices: {
-        average: number;
-        fast: number;
-        slow: number;
-    };
+export type TacGasPrice = {
+    average: number;
+    fast: number;
+    slow: number;
+};
+export type TrackTransactionTreeParams = {
+    maxDepth?: number;
+    ignoreOpcodeList?: number[];
 };