@tonappchain/sdk 0.7.3-rc1 → 0.7.3-rc3

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

@@ -1,6 +1,6 @@
 import { Wallet } from 'ethers';
 import { Asset, IConfiguration, ILogger, IOperationTracker, ITACTransactionManager } from '../interfaces';
-import { BridgeTokensToTONOptions, TACCrossChainTransactionResult } from '../structs/Struct';
+import { CrossChainTransactionToTONOptions, TACCrossChainTransactionResult } from '../structs/Struct';
 export declare class TACTransactionManager implements ITACTransactionManager {
     private readonly config;
     private readonly operationTracker;
@@ -8,6 +8,7 @@ export declare class TACTransactionManager implements ITACTransactionManager {
     constructor(config: IConfiguration, operationTracker: IOperationTracker, logger?: ILogger);
     private prepareBridgeTokensToTON;
     private approveAsset;
-    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: Asset[], options?: BridgeTokensToTONOptions): Promise<TACCrossChainTransactionResult>;
+    private estimateApprovalGas;
+    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: Asset[], options?: CrossChainTransactionToTONOptions): Promise<TACCrossChainTransactionResult>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
 }

package/dist/src/sdk/TACTransactionManager.js

@@ -36,7 +36,6 @@ class TACTransactionManager {
             this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedFee)}`);
             tvmExecutorFee = BigInt(suggestedFee.inTAC);
         }
-        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
         const protocolFee = await this.config.TACParams.crossChainLayer.getProtocolFee();
         const shardsKey = BigInt(Math.round(Math.random() * Consts_1.SHARDS_KEY_RANDOM_RANGE));
         this.logger.debug(`Shards key: ${shardsKey}, Protocol fee: ${protocolFee}`);
@@ -66,29 +65,44 @@ class TACTransactionManager {
             toBridgeNFT,
         };
         return {
-            crossChainLayerAddress,
             outMessagePayload: this.config.artifacts.tac.utils.encodeOutMessageV1(outMessage),
             totalValue: value + BigInt(outMessage.tvmProtocolFee) + BigInt(outMessage.tvmExecutorFee),
         };
     }
     async approveAsset(asset, signer, spenderAddress, transactionParams = {}) {
         const evmAddress = await asset.getEVMAddress();
+        const hasTransactionParams = Object.keys(transactionParams).length > 0;
         if (asset.type === Struct_1.AssetType.FT) {
             this.logger.debug(`Approving FT ${evmAddress} for ${spenderAddress}`);
             const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
-            const tx = await contract.connect(signer).approve(spenderAddress, asset.rawAmount, transactionParams);
+            const tx = hasTransactionParams
+                ? await contract.connect(signer).approve(spenderAddress, asset.rawAmount, transactionParams)
+                : await contract.connect(signer).approve(spenderAddress, asset.rawAmount);
             await tx.wait();
         }
         else {
             this.logger.debug(`Approving NFT ${evmAddress} for ${spenderAddress}`);
             const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
-            const tx = await contract
-                .connect(signer)
-                .approve(spenderAddress, asset.addresses.index, transactionParams);
+            const tx = hasTransactionParams
+                ? await contract
+                    .connect(signer)
+                    .approve(spenderAddress, asset.addresses.index, transactionParams)
+                : await contract.connect(signer).approve(spenderAddress, asset.addresses.index);
             await tx.wait();
         }
         this.logger.debug(`Approved ${evmAddress} for ${spenderAddress}`);
     }
+    async estimateApprovalGas(asset, signer, spenderAddress, transactionParams = {}) {
+        const evmAddress = await asset.getEVMAddress();
+        if (asset.type === Struct_1.AssetType.FT) {
+            const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
+            return contract.connect(signer).approve.estimateGas(spenderAddress, asset.rawAmount, transactionParams);
+        }
+        const contract = new ethers_1.ethers.Contract(evmAddress, this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
+        return contract
+            .connect(signer)
+            .approve.estimateGas(spenderAddress, asset.addresses.index, transactionParams);
+    }
     async sendCrossChainTransactionToTON(signer, tonTarget, assets = [], options) {
         const signerAddress = signer.address;
         const nativeTACAsset = await assets_1.AssetFactory.from(this.config, {
@@ -98,21 +112,22 @@ class TACTransactionManager {
         let value = 0n;
         const bridgeAssets = [];
         for (const asset of assets) {
-            if (asset.origin === Struct_1.Origin.TAC && asset.type === Struct_1.AssetType.FT && asset.address === nativeTACAsset.address) {
+            if (asset.origin === Struct_1.Origin.TAC &&
+                asset.type === Struct_1.AssetType.FT &&
+                asset.address === nativeTACAsset.address) {
                 value += asset.rawAmount;
                 continue;
             }
             bridgeAssets.push(asset);
         }
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
         const preparedBridge = await this.prepareBridgeTokensToTON(value, tonTarget, bridgeAssets, options?.tvmExecutorFee, options?.tvmValidExecutors);
         const feeData = await this.config.TACParams.provider.getFeeData();
         const maxFeePerGas = feeData.maxFeePerGas;
         if (maxFeePerGas === null) {
             throw (0, errors_1.gasPriceFetchError)('TAC provider did not return maxFeePerGas');
         }
-        const latestBlock = await this.config.TACParams.provider
-            .getBlock('latest')
-            .catch((error) => {
+        const latestBlock = await this.config.TACParams.provider.getBlock('latest').catch((error) => {
             throw (0, errors_1.blockGasLimitFetchError)('provider failed to return latest block', error);
         });
         const blockGasLimit = latestBlock?.gasLimit;
@@ -127,28 +142,26 @@ class TACTransactionManager {
         if (shouldValidateAssetsBalance) {
             await Promise.all(bridgeAssets.map((asset) => asset.checkCanBeTransferredBy(signerAddress, Struct_1.BlockchainType.TAC)));
         }
-        let requiredBalance = preparedBridge.totalValue;
+        let requiredApprovalBalance = 0n;
         const approvalPlans = [];
         for (const asset of bridgeAssets) {
-            let estimatedGas;
-            if (asset.type === Struct_1.AssetType.FT) {
-                const contract = new ethers_1.ethers.Contract(await asset.getEVMAddress(), this.config.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this.config.TACParams.provider);
-                estimatedGas = await contract
-                    .connect(signer)
-                    .approve.estimateGas(preparedBridge.crossChainLayerAddress, asset.rawAmount, transactionParams);
-            }
-            else {
-                const contract = new ethers_1.ethers.Contract(await asset.getEVMAddress(), this.config.artifacts.tac.compilationArtifacts.IERC721.abi, this.config.TACParams.provider);
-                estimatedGas = await contract
-                    .connect(signer)
-                    .approve.estimateGas(preparedBridge.crossChainLayerAddress, asset.addresses.index, transactionParams);
-            }
+            const estimatedGas = await this.estimateApprovalGas(asset, signer, crossChainLayerAddress, transactionParams);
             if (estimatedGas > blockGasLimit) {
                 throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('approve', estimatedGas, blockGasLimit);
             }
-            requiredBalance += estimatedGas * maxFeePerGas;
+            requiredApprovalBalance += estimatedGas * maxFeePerGas;
             approvalPlans.push({ asset, gasLimit: estimatedGas });
         }
+        const approvalBalance = await this.config.TACParams.provider.getBalance(signer.address);
+        if (approvalBalance < requiredApprovalBalance) {
+            throw (0, errors_1.insufficientBalanceError)(Consts_1.TAC_SYMBOL);
+        }
+        for (const approval of approvalPlans) {
+            await this.approveAsset(approval.asset, signer, crossChainLayerAddress, {
+                ...transactionParams,
+                gasLimit: approval.gasLimit,
+            });
+        }
         const sendMessageGas = await this.config.TACParams.crossChainLayer
             .connect(signer)
             .sendMessage.estimateGas(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, preparedBridge.outMessagePayload, {
@@ -158,17 +171,11 @@ class TACTransactionManager {
         if (sendMessageGas > blockGasLimit) {
             throw (0, errors_1.estimatedGasExceedsBlockGasLimitError)('sendMessage', sendMessageGas, blockGasLimit);
         }
-        requiredBalance += sendMessageGas * maxFeePerGas;
-        const balance = await this.config.TACParams.provider.getBalance(signer.address);
-        if (balance < requiredBalance) {
+        const requiredSendMessageBalance = preparedBridge.totalValue + sendMessageGas * maxFeePerGas;
+        const sendMessageBalance = await this.config.TACParams.provider.getBalance(signer.address);
+        if (sendMessageBalance < requiredSendMessageBalance) {
             throw (0, errors_1.insufficientBalanceError)(Consts_1.TAC_SYMBOL);
         }
-        for (const approval of approvalPlans) {
-            await this.approveAsset(approval.asset, signer, preparedBridge.crossChainLayerAddress, {
-                ...transactionParams,
-                gasLimit: approval.gasLimit,
-            });
-        }
         const tx = await this.config.TACParams.crossChainLayer
             .connect(signer)
             .sendMessage(Consts_1.CROSS_CHAIN_MESSAGE_VERSION_V1, preparedBridge.outMessagePayload, {
@@ -219,7 +226,10 @@ class TACTransactionManager {
     }
     async bridgeTokensToTON(signer, value, tonTarget, assets = [], tvmExecutorFee, tvmValidExecutors) {
         this.logger.debug('Bridging tokens to TON');
-        const { crossChainLayerAddress, outMessagePayload, totalValue } = await this.prepareBridgeTokensToTON(value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
+        Validator_1.Validator.validateTVMAddress(tonTarget);
+        Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
+        const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
+        const { outMessagePayload, totalValue } = await this.prepareBridgeTokensToTON(value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors);
         this.logger.debug(`Total value: ${totalValue}`);
         for (const asset of assets) {
             await this.approveAsset(asset, signer, crossChainLayerAddress);

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

@@ -3,7 +3,7 @@ import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT, TAC, TON } from '../assets';
 import { ContractOpener, IConfiguration, ILogger, IOperationTracker, ITacExplorerClient, ITacSDK } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, BridgeTokensToTONOptions, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainPayloadResult, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrossChainTransactionToTONOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACCrossChainTransactionResult, TacGasPrice, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly contactOpener: ContractOpener;
@@ -12,6 +12,7 @@ export declare class TacSdk implements ITacSDK {
     private readonly simulator;
     private readonly tonTransactionManager;
     private readonly tacTransactionManager;
+    private readonly tonIndexer;
     private constructor();
     static create(sdkParams: SDKParams, logger?: ILogger): Promise<TacSdk>;
     closeConnections(): unknown;
@@ -23,8 +24,10 @@ export declare class TacSdk implements ITacSDK {
     getSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<ExecutionFeeEstimationResult>;
     getTVMExecutorFeeInfo(assets: AssetLike[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTVMExecutorFee>;
     sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: BridgeTokensToTONOptions): Promise<TACCrossChainTransactionResult>;
+    sendCrossChainTransactionToTON(signer: Wallet, tonTarget: string, assets?: AssetLike[], options?: CrossChainTransactionToTONOptions): Promise<TACCrossChainTransactionResult>;
     sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    getOperationIdByTonTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
+    getOperationIdByTonTransactionBoc(boc: string, waitOptions?: WaitOptions<string> | null): Promise<string>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: AssetLike[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
     isContractDeployedOnTVM(address: string): Promise<boolean>;
     simulateTACMessage(req: TACSimulationParams): Promise<TACSimulationResult>;
@@ -48,4 +51,5 @@ export declare class TacSdk implements ITacSDK {
     prepareCrossChainTransactionPayload(evmProxyMsg: EvmProxyMsg, senderAddress: string, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<CrossChainPayloadResult[]>;
     getTACGasPrice(): Promise<TacGasPrice>;
     getTonContractOpener(): ContractOpener;
+    private toSequencerTonTransactionHash;
 }

package/dist/src/sdk/TacSdk.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
+const ton_1 = require("@ton/ton");
 const artifacts_1 = require("../../artifacts");
+const adapters_1 = require("../adapters");
 const assets_1 = require("../assets");
+const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
@@ -14,7 +17,7 @@ const TACTransactionManager_1 = require("./TACTransactionManager");
 const TONTransactionManager_1 = require("./TONTransactionManager");
 const Utils_1 = require("./Utils");
 class TacSdk {
-    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient) {
+    constructor(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer) {
         this.config = config;
         this.contactOpener = config.TONParams.contractOpener;
         this.simulator = simulator;
@@ -22,6 +25,7 @@ class TacSdk {
         this.tacTransactionManager = tacTransactionManager;
         this.operationTracker = operationTracker;
         this.explorerClient = explorerClient;
+        this.tonIndexer = tonIndexer;
     }
     static async create(sdkParams, logger = new Logger_1.NoopLogger()) {
         const network = sdkParams.network;
@@ -47,7 +51,8 @@ class TacSdk {
         const simulator = new Simulator_1.Simulator(config, operationTracker, logger);
         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);
+        const tonIndexer = sdkParams.TONParams?.tonIndexer ?? new adapters_1.ToncenterV3Indexer(artifacts.TONCENTER_V3_INDEXER_ENDPOINT);
+        return new TacSdk(config, simulator, tonTransactionManager, tacTransactionManager, operationTracker, explorerClient, tonIndexer);
     }
     closeConnections() {
         return this.config.closeConnections();
@@ -99,6 +104,32 @@ class TacSdk {
         })));
         return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, options);
     }
+    async getOperationIdByTonTransactionHash(transactionHash, waitOptions) {
+        const cclTransaction = await this.tonIndexer.findCollectibleCrossChainLayerTransaction(transactionHash, this.config.TONParams.crossChainLayerAddress);
+        if (!cclTransaction) {
+            return '';
+        }
+        return this.operationTracker.getOperationIdByTonTransactionHash(this.toSequencerTonTransactionHash(cclTransaction), waitOptions);
+    }
+    async getOperationIdByTonTransactionBoc(boc, waitOptions) {
+        let message;
+        try {
+            message = (0, ton_1.loadMessage)(ton_1.Cell.fromBase64(boc).beginParse());
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : undefined;
+            throw (0, errors_1.invalidTonExternalMessageBocError)(reason);
+        }
+        if (message.info.type !== 'external-in') {
+            throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
+        }
+        const destination = message.info.dest;
+        const transaction = await this.contactOpener.getTransactionByHash(ton_1.Address.parse(destination.toString()), (0, Utils_1.getNormalizedExtMessageHash)(message));
+        if (!transaction) {
+            return '';
+        }
+        return this.getOperationIdByTonTransactionHash(transaction.hash().toString('base64'), waitOptions);
+    }
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
         return this.tacTransactionManager.bridgeTokensToTON(signer, value, tonTarget, normalizedAssets, tvmExecutorFee, tvmValidExecutors);
@@ -204,5 +235,8 @@ class TacSdk {
     getTonContractOpener() {
         return this.contactOpener;
     }
+    toSequencerTonTransactionHash(transaction) {
+        return `0x${(0, Utils_1.normalizeHashToHex)(transaction.hash)}`;
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/src/sdk/Utils.js

@@ -416,7 +416,7 @@ function decodeBase64Like(input) {
 }
 function getNormalizedExtMessageHash(message) {
     if (message.info.type !== 'external-in') {
-        throw new Error(`Message must be "external-in", got ${message.info.type}`);
+        throw (0, errors_1.externalInMessageRequiredError)(message.info.type);
     }
     const info = {
         ...message.info,
@@ -460,5 +460,5 @@ function recurisivelyCollectCellStats(cell) {
     return { bits, cells };
 }
 function isFinalProfiling(profilingData) {
-    return profilingData.operationType !== Struct_1.OperationType.PENDING && profilingData.operationType !== Struct_1.OperationType.UNKNOWN;
+    return (profilingData.operationType !== Struct_1.OperationType.PENDING && profilingData.operationType !== Struct_1.OperationType.UNKNOWN);
 }

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

@@ -2,7 +2,7 @@ import { Address, Cell } from '@ton/ton';
 import { AbstractProvider, ethers } from 'ethers';
 import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
 import { ContractOpener } from '../interfaces';
-import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, TransactionLinker } from './Struct';
+import { CurrencyType, ExecutionStagesByOperationId, ExecutionStagesV2ByOperationId, Network, OperationIdsByShardsKey, OperationIdWithLogIndex, OperationType, OperationTypeV2Info, StatusInfosByOperationId, SuggestedTVMExecutorFee, TACSimulationResult, ToncenterV3IndexedTransaction, TransactionLinker } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -22,7 +22,6 @@ export type PreparedCrossChainTransaction = {
     transactionLinker: TransactionLinker;
 };
 export type PreparedBridgeTokensToTON = {
-    crossChainLayerAddress: string;
     outMessagePayload: ethers.BytesLike;
     totalValue: bigint;
 };
@@ -71,11 +70,7 @@ export type StageProfilingV2Response = ResponseBase<ExecutionStagesV2ByOperation
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
 export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
 export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
-export type OperationIdWithLogIndex = {
-    operationId: string;
-    logIndex: number;
-};
-export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex>;
+export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex[]>;
 export interface SendResult {
     success: boolean;
     boc: string;
@@ -138,6 +133,12 @@ export type TransactionDepth = {
 export type AdjacentTransactionsResponse = {
     transactions: ToncenterTransaction[];
 };
+export type TonAdjacentTransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
+export type ToncenterV3TransactionsResponse = {
+    transactions: ToncenterV3IndexedTransaction[];
+};
 export type TxFinalizerConfig = {
     urlBuilder: (hash: string) => string;
     authorization?: {

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

@@ -3,7 +3,7 @@ import { Cell, OpenedContract } from '@ton/ton';
 import { AbstractProvider } from 'ethers';
 import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
 import type { FT, NFT } from '../assets';
-import type { Asset, ContractOpener, ILogger } from '../interfaces';
+import type { Asset, ContractOpener, ILogger, IToncenterV3Indexer } from '../interfaces';
 import { SendResult } from './InternalStruct';
 export type ContractState = {
     balance: bigint;
@@ -61,6 +61,11 @@ export type TONParams = {
      * Provider for TON side. Use your own provider for tests or to increase ratelimit
      */
     contractOpener?: ContractOpener;
+    /**
+     * Indexed Toncenter v3 client used to resolve TON transaction context by hash.
+     * Use your own implementation for tests or custom indexed backends.
+     */
+    tonIndexer?: IToncenterV3Indexer;
     /**
      * Address of TON settings contract. Use only for tests.
      */
@@ -182,6 +187,54 @@ export type StageData = {
 export type StatusInfo = StageData & {
     stage: StageName;
 };
+/**
+ * Indexed transaction returned by Toncenter v3 `/transactions` and `/adjacentTransactions` endpoints.
+ */
+export type ToncenterV3IndexedTransaction = {
+    /** Account address that owns the transaction. */
+    account: string;
+    /** Indexed TON transaction hash. */
+    hash: string;
+    /** Optional trace identifier returned by Toncenter v3. */
+    traceId?: string;
+    /** Incoming message of the indexed transaction, when present in the response. */
+    inMsg?: {
+        /** Message source address. */
+        source?: string | null;
+        /** Message destination address. */
+        destination?: string | null;
+        /** Opcode reported by Toncenter v3 for the incoming message. */
+        opcode?: string | null;
+        /** Raw message content returned by Toncenter v3. */
+        messageContent?: {
+            /** BOC-encoded message body in base64 form. */
+            body?: string | null;
+        } | null;
+    } | null;
+    /** Outgoing messages of the indexed transaction. */
+    outMsgs: Array<{
+        /** Message destination address. `null` means external outbound log message. */
+        destination?: string | null;
+        /** Raw message content returned by Toncenter v3. */
+        messageContent?: {
+            /** BOC-encoded message body in base64 form. */
+            body?: string | null;
+        } | null;
+    }>;
+};
+/**
+ * Traversal settings for indexed search through a linked TON transaction chain in Toncenter v3.
+ */
+export type ToncenterV3TraversalParams = {
+    /**
+     * Maximum traversal depth from the starting transaction in the linked TON transaction chain.
+     */
+    maxDepth?: number;
+    /**
+     * Maximum number of unique indexed transactions to inspect.
+     */
+    maxScannedTransactions?: number;
+};
 export type ProfilingStageData = {
     exists: boolean;
     stageData: StageData | null;
@@ -257,6 +310,10 @@ export type StatusInfosByOperationId = Record<string, StatusInfo>;
 export type OperationIds = {
     operationIds: string[];
 };
+export type OperationIdWithLogIndex = {
+    operationId: string;
+    logIndex: number;
+};
 export type OperationIdsByShardsKey = Record<string, OperationIds>;
 export type TACSimulationResult = {
     estimatedGas: bigint;
@@ -419,7 +476,7 @@ export type CrossChainTransactionsOptions = {
     waitOperationIds?: boolean;
     waitOptions?: WaitOptions<OperationIdsByShardsKey>;
 };
-export type BridgeTokensToTONOptions = {
+export type CrossChainTransactionToTONOptions = {
     /**
      * Optional explicit TON-side executor fee.
      * When omitted, the SDK calls OperationTracker.getTVMExecutorFee().
@@ -541,6 +598,11 @@ export declare enum Origin {
     TON = "TON",
     TAC = "TAC"
 }
+export declare enum AssetFeeMode {
+    TAC_ORIGINAL = "TAC_ORIGINAL",
+    LEGACY = "LEGACY",
+    DYNAMIC = "DYNAMIC"
+}
 export type TVMAddress = string;
 export type EVMAddress = string;
 export type AssetFromFTArg = {

package/dist/src/structs/Struct.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionTreeDirection = exports.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationExecutionStatus = exports.OperationType = exports.CurrencyType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
+exports.TransactionTreeDirection = exports.AssetFeeMode = exports.Origin = exports.defaultWaitOptions = exports.TokenSymbol = exports.StageName = exports.NFTAddressType = exports.AssetType = exports.OperationExecutionStatus = exports.OperationType = exports.CurrencyType = exports.BlockchainType = exports.Network = exports.SimplifiedStatuses = void 0;
 const Consts_1 = require("../sdk/Consts");
 var SimplifiedStatuses;
 (function (SimplifiedStatuses) {
@@ -73,6 +73,12 @@ var Origin;
     Origin["TON"] = "TON";
     Origin["TAC"] = "TAC";
 })(Origin || (exports.Origin = Origin = {}));
+var AssetFeeMode;
+(function (AssetFeeMode) {
+    AssetFeeMode["TAC_ORIGINAL"] = "TAC_ORIGINAL";
+    AssetFeeMode["LEGACY"] = "LEGACY";
+    AssetFeeMode["DYNAMIC"] = "DYNAMIC";
+})(AssetFeeMode || (exports.AssetFeeMode = AssetFeeMode = {}));
 var TransactionTreeDirection;
 (function (TransactionTreeDirection) {
     TransactionTreeDirection["FORWARD"] = "forward";

package/package.json

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