@tonappchain/sdk 0.7.2 → 0.7.3-rc2

package/dist/src/adapters/BaseContractOpener.js

@@ -5,6 +5,7 @@ const ton_1 = require("@ton/ton");
 const errors_1 = require("../errors");
 const Consts_1 = require("../sdk/Consts");
 const Utils_1 = require("../sdk/Utils");
+const Struct_1 = require("../structs/Struct");
 /**
  * Base class for ContractOpener implementations with common functionality
  */
@@ -327,7 +328,7 @@ class BaseContractOpener {
         maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
-        direction: 'both',
+        direction: Struct_1.TransactionTreeDirection.FORWARD,
         retryOnNotFound: Consts_1.DEFAULT_RETRY_ON_NOT_FOUND,
     }) {
         const result = await this.trackTransactionTreeWithResult(address, hash, params);
@@ -353,10 +354,10 @@ class BaseContractOpener {
         maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
         ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
         limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
-        direction: 'both',
+        direction: Struct_1.TransactionTreeDirection.FORWARD,
         retryOnNotFound: Consts_1.DEFAULT_RETRY_ON_NOT_FOUND,
     }) {
-        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, maxScannedTransactions = Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS, direction = 'both', retryOnNotFound = Consts_1.DEFAULT_RETRY_ON_NOT_FOUND, retryDelayMs, retries, } = params;
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, maxScannedTransactions = Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS, direction = Struct_1.TransactionTreeDirection.FORWARD, retryOnNotFound = Consts_1.DEFAULT_RETRY_ON_NOT_FOUND, retryDelayMs, retries, } = params;
         const parsedAddress = ton_1.Address.parse(address);
         const normalizedRootHash = (0, Utils_1.normalizeHashToBase64)(hash);
         const visitedSearchKeys = new Set();
@@ -410,7 +411,8 @@ class BaseContractOpener {
             }
             // Add adjacent transactions to queue
             if (currentDepth < maxDepth) {
-                if ((direction === 'forward' || direction === 'both') && tx.outMessages.size > 0) {
+                if ((direction === Struct_1.TransactionTreeDirection.FORWARD || direction === Struct_1.TransactionTreeDirection.BOTH) &&
+                    tx.outMessages.size > 0) {
                     for (const msg of tx.outMessages.values()) {
                         const dst = msg.info.dest;
                         if (!dst || dst instanceof ton_1.ExternalAddress)
@@ -424,7 +426,8 @@ class BaseContractOpener {
                     }
                 }
                 // Backward: add parent (incoming message source)
-                if ((direction === 'backward' || direction === 'both') && tx.inMessage?.info.type === 'internal') {
+                if ((direction === Struct_1.TransactionTreeDirection.BACKWARD || direction === Struct_1.TransactionTreeDirection.BOTH) &&
+                    tx.inMessage?.info.type === 'internal') {
                     queue.push({
                         hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64'),
                         address: tx.inMessage.info.src,

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

@@ -7,8 +7,12 @@ export interface OpenerConfig {
     opener: ContractOpener;
     /** Number of retry attempts before falling back to the next opener. */
     retries: number;
-    /** Delay in milliseconds between retries for this opener. */
+    /** Base delay in milliseconds between retries for this opener. */
     retryDelay: number;
+    /** Upper bound for exponential backoff delay in milliseconds. */
+    maxRetryDelay?: number;
+    /** Exponential backoff multiplier applied after each failed retry. */
+    retryBackoffMultiplier?: number;
 }
 export declare class RetryableContractOpener implements ContractOpener {
     private readonly openerConfigs;
@@ -32,6 +36,7 @@ export declare class RetryableContractOpener implements ContractOpener {
     private executeWithFallback;
     private trySingleAttempt;
     private tryWithRetries;
+    private getRetryDelay;
     private isContractExecutionError;
     private isTransportError;
     private createRetryableContract;

package/dist/src/adapters/RetryableContractOpener.js

@@ -22,9 +22,7 @@ class RetryableContractOpener {
         }
     }
     setLogger(logger) {
-        if (!this.logger) {
-            this.logger = logger;
-        }
+        this.logger = logger;
         this.applyLoggerToOpeners(logger);
     }
     applyLoggerToOpeners(logger) {
@@ -199,13 +197,24 @@ class RetryableContractOpener {
                     return { success: false, lastError };
                 }
                 if (attempt < config.retries) {
-                    this.logger?.debug(`[RetryableContractOpener] ${operationContext}: attempt ${attempt + 1}/${config.retries + 1} failed (${lastError.message}), retrying in ${config.retryDelay}ms`);
-                    await sleep(config.retryDelay);
+                    const retryDelay = this.getRetryDelay(config, attempt);
+                    this.logger?.debug(`[RetryableContractOpener] ${operationContext}: attempt ${attempt + 1}/${config.retries + 1} failed (${lastError.message}), retrying in ${retryDelay}ms`);
+                    await sleep(retryDelay);
                 }
             }
         }
         return { success: false, lastError };
     }
+    getRetryDelay(config, attempt) {
+        const baseDelay = config.retryDelay ?? Consts_1.DEFAULT_RETRY_DELAY_MS;
+        const maxRetryDelay = config.maxRetryDelay ?? Consts_1.DEFAULT_RETRY_MAX_DELAY_MS;
+        const backoffMultiplier = config.retryBackoffMultiplier ?? Consts_1.DEFAULT_RETRY_BACKOFF_MULTIPLIER;
+        if (baseDelay === 0 || maxRetryDelay === 0) {
+            return 0;
+        }
+        const calculatedDelay = baseDelay * backoffMultiplier ** attempt;
+        return Math.min(Math.round(calculatedDelay), maxRetryDelay);
+    }
     isContractExecutionError(error) {
         const errorWithExit = error;
         if (typeof errorWithExit.exitCode === 'number' ||
@@ -269,18 +278,36 @@ async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetr
         timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS,
     });
     const opener = (0, TonClientOpener_1.tonClientOpener)(tonClient, logger);
-    openers.push({ opener, retries: maxRetries, retryDelay });
+    openers.push({
+        opener,
+        retries: maxRetries,
+        retryDelay,
+        maxRetryDelay: Consts_1.DEFAULT_RETRY_MAX_DELAY_MS,
+        retryBackoffMultiplier: Consts_1.DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+    });
     if (networkType !== Struct_1.Network.DEV) {
         try {
             const opener = await (0, TonClientOpener_1.orbsOpener)(networkType, logger);
-            openers.push({ opener: opener, retries: maxRetries, retryDelay });
+            openers.push({
+                opener: opener,
+                retries: maxRetries,
+                retryDelay,
+                maxRetryDelay: Consts_1.DEFAULT_RETRY_MAX_DELAY_MS,
+                retryBackoffMultiplier: Consts_1.DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+            });
         }
         catch {
             // skip opener in case of failure
         }
         try {
             const opener4 = await (0, TonClient4Opener_1.orbsOpener4)(networkType, Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger);
-            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
+            openers.push({
+                opener: opener4,
+                retries: maxRetries,
+                retryDelay,
+                maxRetryDelay: Consts_1.DEFAULT_RETRY_MAX_DELAY_MS,
+                retryBackoffMultiplier: Consts_1.DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+            });
         }
         catch {
             // skip opener in case of failure

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

@@ -0,0 +1,34 @@
+import { IHttpClient, IToncenterV3Indexer } from '../interfaces';
+import { ToncenterV3IndexedTransaction, ToncenterV3TraversalParams } from '../structs/Struct';
+/**
+ * Thin Toncenter v3 indexer client for resolving indexed TON transaction context by hash and
+ * traversing a linked chain of TON transactions until it finds the sequencer-collected event transaction on CCL.
+ */
+export declare class ToncenterV3Indexer implements IToncenterV3Indexer {
+    readonly endpoint: string;
+    private readonly httpClient;
+    constructor(endpoint: string, httpClient?: IHttpClient);
+    /**
+     * Queries Toncenter v3 indexed `/transactions` endpoint by hash and returns the first match.
+     * @param transactionHash TON transaction hash accepted by the indexer.
+     * @returns Indexed transaction with owning account context, or null on 404 / empty result.
+     */
+    getTransactionByHash(transactionHash: string): Promise<ToncenterV3IndexedTransaction | null>;
+    /**
+     * Queries Toncenter v3 indexed `/adjacentTransactions` endpoint by hash.
+     * @param transactionHash TON transaction hash accepted by the indexer.
+     * @returns Adjacent indexed transactions, or an empty array on 404 / empty result.
+     */
+    getAdjacentTransactions(transactionHash: string): Promise<ToncenterV3IndexedTransaction[]>;
+    /**
+     * Traverses the linked chain of TON transactions in both directions starting from any TON transaction hash
+     * from that linked transaction chain, and returns the transaction on crossChainLayer that the sequencer would collect
+     * as a TVM event.
+     * @param transactionHash Any TON transaction hash from the target linked chain of TON transactions.
+     * @param crossChainLayerAddress crossChainLayer address whose sequencer-collected event transaction should be found in that linked chain of TON transactions.
+     * @param params Optional traversal settings. Defaults match the SDK traversal defaults.
+     * @returns Indexed crossChainLayer transaction that matches the sequencer collector rules, or null if not found.
+     */
+    findCollectibleCrossChainLayerTransaction(transactionHash: string, crossChainLayerAddress: string, params?: ToncenterV3TraversalParams): Promise<ToncenterV3IndexedTransaction | null>;
+    private isCollectibleEventTransactionOnAccount;
+}

package/dist/src/adapters/ToncenterV3Indexer.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToncenterV3Indexer = void 0;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const AxiosHttpClient_1 = require("../sdk/AxiosHttpClient");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+/**
+ * Thin Toncenter v3 indexer client for resolving indexed TON transaction context by hash and
+ * traversing a linked chain of TON transactions until it finds the sequencer-collected event transaction on CCL.
+ */
+class ToncenterV3Indexer {
+    constructor(endpoint, httpClient = new AxiosHttpClient_1.AxiosHttpClient()) {
+        this.endpoint = endpoint;
+        this.httpClient = httpClient;
+    }
+    /**
+     * Queries Toncenter v3 indexed `/transactions` endpoint by hash and returns the first match.
+     * @param transactionHash TON transaction hash accepted by the indexer.
+     * @returns Indexed transaction with owning account context, or null on 404 / empty result.
+     */
+    async getTransactionByHash(transactionHash) {
+        const endpoint = this.endpoint.endsWith('/') ? `${this.endpoint}transactions` : `${this.endpoint}/transactions`;
+        const requestLabel = `GET ${endpoint}`;
+        try {
+            const response = await this.httpClient.get(endpoint, {
+                params: {
+                    hash: transactionHash,
+                    limit: 1,
+                },
+                transformResponse: [Utils_1.toCamelCaseTransformer],
+            });
+            return response.data.transactions?.[0] ?? null;
+        }
+        catch (error) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (error?.response?.status === 404) {
+                return null;
+            }
+            throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to resolve TON indexed transaction`, error);
+        }
+    }
+    /**
+     * Queries Toncenter v3 indexed `/adjacentTransactions` endpoint by hash.
+     * @param transactionHash TON transaction hash accepted by the indexer.
+     * @returns Adjacent indexed transactions, or an empty array on 404 / empty result.
+     */
+    async getAdjacentTransactions(transactionHash) {
+        const endpoint = this.endpoint.endsWith('/') ? `${this.endpoint}adjacentTransactions` : `${this.endpoint}/adjacentTransactions`;
+        const requestLabel = `GET ${endpoint}`;
+        try {
+            const response = await this.httpClient.get(endpoint, {
+                params: {
+                    hash: transactionHash,
+                },
+                transformResponse: [Utils_1.toCamelCaseTransformer],
+            });
+            return response.data.transactions ?? [];
+        }
+        catch (error) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (error?.response?.status === 404) {
+                return [];
+            }
+            throw (0, errors_1.operationFetchError)(`request ${requestLabel} failed to resolve adjacent TON indexed transactions`, error);
+        }
+    }
+    /**
+     * Traverses the linked chain of TON transactions in both directions starting from any TON transaction hash
+     * from that linked transaction chain, and returns the transaction on crossChainLayer that the sequencer would collect
+     * as a TVM event.
+     * @param transactionHash Any TON transaction hash from the target linked chain of TON transactions.
+     * @param crossChainLayerAddress crossChainLayer address whose sequencer-collected event transaction should be found in that linked chain of TON transactions.
+     * @param params Optional traversal settings. Defaults match the SDK traversal defaults.
+     * @returns Indexed crossChainLayer transaction that matches the sequencer collector rules, or null if not found.
+     */
+    async findCollectibleCrossChainLayerTransaction(transactionHash, crossChainLayerAddress, params) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, maxScannedTransactions = Consts_1.DEFAULT_MAX_SCANNED_TRANSACTIONS, } = params ?? {};
+        const crossChainLayer = ton_1.Address.parse(crossChainLayerAddress);
+        const rootTransaction = await this.getTransactionByHash(transactionHash);
+        if (!rootTransaction) {
+            return null;
+        }
+        if (this.isCollectibleEventTransactionOnAccount(rootTransaction, crossChainLayer)) {
+            return rootTransaction;
+        }
+        const queue = [{ hash: rootTransaction.hash, depth: 0 }];
+        const visitedHashes = new Set([(0, Utils_1.normalizeHashToHex)(rootTransaction.hash)]);
+        let scannedTransactions = 0;
+        while (queue.length > 0) {
+            const { hash: currentHash, depth } = queue.shift();
+            if (depth >= maxDepth || scannedTransactions >= maxScannedTransactions) {
+                continue;
+            }
+            const adjacentTransactions = await this.getAdjacentTransactions(currentHash);
+            for (const transaction of adjacentTransactions) {
+                const normalizedHash = (0, Utils_1.normalizeHashToHex)(transaction.hash);
+                if (visitedHashes.has(normalizedHash)) {
+                    continue;
+                }
+                visitedHashes.add(normalizedHash);
+                scannedTransactions += 1;
+                if (this.isCollectibleEventTransactionOnAccount(transaction, crossChainLayer)) {
+                    return transaction;
+                }
+                if (scannedTransactions < maxScannedTransactions) {
+                    queue.push({ hash: transaction.hash, depth: depth + 1 });
+                }
+            }
+        }
+        return null;
+    }
+    isCollectibleEventTransactionOnAccount(transaction, account) {
+        if (!ton_1.Address.parse(transaction.account).equals(account)) {
+            return false;
+        }
+        return transaction.outMsgs.some((message) => {
+            return message.destination == null;
+        });
+    }
+}
+exports.ToncenterV3Indexer = ToncenterV3Indexer;

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

@@ -3,5 +3,6 @@ export * from './LiteClientOpener';
 export * from './OpenerUtils';
 export * from './RetryableContractOpener';
 export * from './SandboxOpener';
+export * from './ToncenterV3Indexer';
 export * from './TonClient4Opener';
 export * from './TonClientOpener';

package/dist/src/adapters/index.js

@@ -19,5 +19,6 @@ __exportStar(require("./LiteClientOpener"), exports);
 __exportStar(require("./OpenerUtils"), exports);
 __exportStar(require("./RetryableContractOpener"), exports);
 __exportStar(require("./SandboxOpener"), exports);
+__exportStar(require("./ToncenterV3Indexer"), exports);
 __exportStar(require("./TonClient4Opener"), exports);
 __exportStar(require("./TonClientOpener"), exports);

package/dist/src/assets/AssetFactory.d.ts

@@ -1,7 +1,10 @@
 import { Asset, IConfiguration } from '../interfaces';
 import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
+import { FT } from './FT';
+import { TAC } from './TAC';
+import { TON } from './TON';
 export declare class AssetFactory {
     static from(configuration: IConfiguration, token: AssetFromFTArg | AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<Asset>;
-    static createFTAsset(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<Asset>;
+    static createFTAsset(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<FT | TAC | TON>;
     static createNFTAsset(configuration: IConfiguration, address: TVMAddress | EVMAddress, addressType: NFTAddressType, index?: bigint): Promise<Asset>;
 }

package/dist/src/assets/AssetFactory.js

@@ -7,6 +7,7 @@ const Struct_1 = require("../structs/Struct");
 const AssetCache_1 = require("./AssetCache");
 const FT_1 = require("./FT");
 const NFT_1 = require("./NFT");
+const TAC_1 = require("./TAC");
 const TON_1 = require("./TON");
 class AssetFactory {
     static async from(configuration, token) {
@@ -35,6 +36,9 @@ class AssetFactory {
             address === Consts_1.TON_BURN_ADDRESS) {
             return ton;
         }
+        if (address === (await configuration.nativeTACAddress())) {
+            return TAC_1.TAC.create(configuration);
+        }
         return FT_1.FT.fromAddress(configuration, address);
     }
     static async createNFTAsset(configuration, address, addressType, index) {

package/dist/src/assets/FT.d.ts

@@ -3,7 +3,7 @@ import { Cell, OpenedContract } from '@ton/ton';
 import { JettonMinterData, JettonWallet } from '../../artifacts/tonTypes';
 import { Asset, IConfiguration } from '../interfaces';
 import { AssetOpType } from '../structs/InternalStruct';
-import { AssetType, EVMAddress, FeeParams, FTOriginAndData, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetType, BlockchainType, EVMAddress, FeeParams, FTOriginAndData, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
 import { Origin } from '../structs/Struct';
 export declare class FT implements Asset {
     private _tvmAddress;
@@ -55,8 +55,8 @@ export declare class FT implements Asset {
     getUserBalance(userAddress: string): Promise<bigint>;
     getUserBalanceExtended(userAddress: string): Promise<UserWalletBalanceExtended>;
     checkBalance(userAddress: string): Promise<void>;
-    checkCanBeTransferredBy(userAddress: string): Promise<void>;
-    getBalanceOf(userAddress: string): Promise<bigint>;
+    checkCanBeTransferredBy(userAddress: string, blockchainType?: BlockchainType): Promise<void>;
+    getBalanceOf(userAddress: string, blockchainType?: BlockchainType): Promise<bigint>;
     private getTransferPayload;
     private getBurnPayload;
 }

package/dist/src/assets/FT.js

@@ -122,20 +122,18 @@ class FT {
                 throw errors_1.missingJettonDataError;
             }
             const metadata = await (0, ContentUtils_1.readJettonMetadata)(jettonData.content);
-            const decimalsRaw = metadata.metadata.decimals ?? Consts_1.TON_DECIMALS;
+            const decimalsRaw = metadata.metadata?.decimals ?? Consts_1.TON_DECIMALS;
             if (decimalsRaw === undefined) {
                 throw errors_1.missingDecimals;
             }
             decimals = Number(decimalsRaw);
         }
         else {
-            if ((0, ethers_1.isAddress)(address)) {
-                finalEvmAddress = address;
-            }
-            else {
-                finalEvmAddress = cachedEvmAddress || (await jettonMinter.getEVMTokenAddress());
-            }
-            decimals = await this.getTACDecimals(configuration, finalEvmAddress);
+            const resolvedEvmAddress = (0, ethers_1.isAddress)(address)
+                ? address
+                : (cachedEvmAddress ?? (await jettonMinter.getEVMTokenAddress()));
+            finalEvmAddress = resolvedEvmAddress;
+            decimals = await this.getTACDecimals(configuration, resolvedEvmAddress);
         }
         const token = new FT(tvmAddress, origin, configuration, decimals);
         if (finalEvmAddress || (0, ethers_1.isAddress)(address)) {
@@ -224,17 +222,19 @@ class FT {
             return this._evmAddress;
         }
         const tokenAddressString = this._tvmAddress.toString({ bounceable: true });
+        let evmAddress;
         if (this.origin === Struct_2.Origin.TON) {
-            this._evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
+            evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
         }
         else if (this.origin === Struct_2.Origin.TAC) {
             const givenMinter = this._configuration.TONParams.contractOpener.open(this._configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(tokenAddressString)));
-            this._evmAddress = await givenMinter.getEVMTokenAddress();
+            evmAddress = await givenMinter.getEVMTokenAddress();
         }
         else {
             throw (0, errors_1.unknownTokenTypeError)(tokenAddressString, 'Token origin is neither TON nor TAC');
         }
-        return this._evmAddress;
+        this._evmAddress = evmAddress;
+        return evmAddress;
     }
     async getTVMAddress() {
         return this._tvmAddress.toString({ bounceable: true });
@@ -290,11 +290,24 @@ class FT {
             throw (0, errors_1.insufficientBalanceError)(this._tvmAddress.toString());
         }
     }
-    async checkCanBeTransferredBy(userAddress) {
-        await this.checkBalance(userAddress);
+    async checkCanBeTransferredBy(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if ((await this.getBalanceOf(userAddress, blockchainType)) < this._transferAmount) {
+            throw (0, errors_1.insufficientBalanceError)(this._tvmAddress.toString());
+        }
     }
-    async getBalanceOf(userAddress) {
-        return this.getUserBalance(userAddress);
+    async getBalanceOf(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if (blockchainType === Struct_1.BlockchainType.TON) {
+            Validator_1.Validator.validateTVMAddress(userAddress);
+            return this.getUserBalance(userAddress);
+        }
+        Validator_1.Validator.validateEVMAddress(userAddress);
+        const evmAddress = await this.getEVMAddress();
+        const nativeTACAddress = await this._configuration.nativeTACAddress();
+        if (evmAddress === nativeTACAddress) {
+            return this._configuration.TACParams.provider.getBalance(userAddress);
+        }
+        const erc20Token = new ethers_1.ethers.Contract(evmAddress, this._configuration.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi, this._configuration.TACParams.provider);
+        return erc20Token.balanceOf(userAddress);
     }
     getTransferPayload(rawAmount, notificationReceiverAddress, responseAddress, evmData, crossChainTonAmount, forwardFeeAmount, feeData) {
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;

package/dist/src/assets/NFT.d.ts

@@ -1,7 +1,7 @@
 import { Cell } from '@ton/ton';
 import { NFTCollectionData, NFTItemData } from '../../artifacts/tonTypes';
 import { Asset, IConfiguration } from '../interfaces';
-import { AssetType, EVMAddress, FeeParams, Origin, TVMAddress } from '../structs/Struct';
+import { AssetType, BlockchainType, EVMAddress, FeeParams, Origin, TVMAddress } from '../structs/Struct';
 export declare class NFT implements Asset {
     private readonly _addresses;
     readonly origin: Origin;
@@ -61,8 +61,8 @@ export declare class NFT implements Asset {
         feeParams?: FeeParams;
     }): Cell;
     isOwnedBy(userAddress: string): Promise<boolean>;
-    checkCanBeTransferredBy(userAddress: string): Promise<void>;
-    getBalanceOf(userAddress: string): Promise<bigint>;
+    checkCanBeTransferredBy(userAddress: string, blockchainType?: BlockchainType): Promise<void>;
+    getBalanceOf(userAddress: string, blockchainType?: BlockchainType): Promise<bigint>;
     private getBurnPayload;
     private getTransferPayload;
 }

package/dist/src/assets/NFT.js

@@ -207,13 +207,19 @@ class NFT {
         const nftData = await NFT.getItemData(this._configuration, this.address.toString());
         return !!nftData.ownerAddress?.equals(ton_1.Address.parse(userAddress));
     }
-    async checkCanBeTransferredBy(userAddress) {
-        if (!(await this.isOwnedBy(userAddress))) {
+    async checkCanBeTransferredBy(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if ((await this.getBalanceOf(userAddress, blockchainType)) < 1n) {
             throw (0, errors_1.insufficientBalanceError)(this.address.toString());
         }
     }
-    async getBalanceOf(userAddress) {
-        return (await this.isOwnedBy(userAddress)) ? 1n : 0n;
+    async getBalanceOf(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if (blockchainType === Struct_1.BlockchainType.TON) {
+            Validator_1.Validator.validateTVMAddress(userAddress);
+            return (await this.isOwnedBy(userAddress)) ? 1n : 0n;
+        }
+        Validator_1.Validator.validateEVMAddress(userAddress);
+        const nft = new ethers_1.ethers.Contract(await this.getEVMAddress(), this._configuration.artifacts.tac.compilationArtifacts.IERC721.abi, this._configuration.TACParams.provider);
+        return (await nft.ownerOf(this._addresses.index)).toLowerCase() === userAddress.toLowerCase() ? 1n : 0n;
     }
     getBurnPayload(crossChainLayerAddress, evmData, crossChainTonAmount, feeData) {
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;

package/dist/src/assets/TAC.d.ts

@@ -0,0 +1,24 @@
+import type { Cell } from '@ton/ton';
+import { Asset, IConfiguration } from '../interfaces';
+import { AssetType, BlockchainType, GeneratePayloadParams, Origin } from '../structs/Struct';
+export declare class TAC implements Asset {
+    private readonly _configuration;
+    private readonly _evmAddress;
+    private _wrappedAsset;
+    readonly type: AssetType;
+    readonly origin: Origin;
+    private constructor();
+    static create(configuration: IConfiguration): Promise<TAC>;
+    get address(): string;
+    get rawAmount(): bigint;
+    get clone(): TAC;
+    withAmount(amount: number): TAC;
+    withRawAmount(rawAmount: bigint): TAC;
+    addAmount(amount: number): TAC;
+    addRawAmount(rawAmount: bigint): TAC;
+    getEVMAddress(): Promise<string>;
+    getTVMAddress(): Promise<string>;
+    generatePayload(params: GeneratePayloadParams): Cell;
+    checkCanBeTransferredBy(userAddress: string, blockchainType?: BlockchainType): Promise<void>;
+    getBalanceOf(userAddress: string, blockchainType?: BlockchainType): Promise<bigint>;
+}

package/dist/src/assets/TAC.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAC = void 0;
+const errors_1 = require("../errors");
+const Validator_1 = require("../sdk/Validator");
+const Struct_1 = require("../structs/Struct");
+const FT_1 = require("./FT");
+class TAC {
+    constructor(_configuration, _evmAddress, _wrappedAsset) {
+        this._configuration = _configuration;
+        this._evmAddress = _evmAddress;
+        this._wrappedAsset = _wrappedAsset;
+        this.type = Struct_1.AssetType.FT;
+        this.origin = Struct_1.Origin.TAC;
+    }
+    static async create(configuration) {
+        const evmAddress = await configuration.nativeTACAddress();
+        const wrappedAsset = await FT_1.FT.fromAddress(configuration, evmAddress);
+        return new TAC(configuration, evmAddress, wrappedAsset);
+    }
+    get address() {
+        return this._wrappedAsset.address;
+    }
+    get rawAmount() {
+        return this._wrappedAsset.rawAmount;
+    }
+    get clone() {
+        return new TAC(this._configuration, this._evmAddress, this._wrappedAsset.clone);
+    }
+    withAmount(amount) {
+        const nextWrappedAsset = this._wrappedAsset.withAmount(amount);
+        if (nextWrappedAsset === this._wrappedAsset) {
+            return this;
+        }
+        return new TAC(this._configuration, this._evmAddress, nextWrappedAsset);
+    }
+    withRawAmount(rawAmount) {
+        const nextWrappedAsset = this._wrappedAsset.withRawAmount(rawAmount);
+        if (nextWrappedAsset === this._wrappedAsset) {
+            return this;
+        }
+        return new TAC(this._configuration, this._evmAddress, nextWrappedAsset);
+    }
+    addAmount(amount) {
+        this._wrappedAsset = this._wrappedAsset.addAmount(amount);
+        return this;
+    }
+    addRawAmount(rawAmount) {
+        this._wrappedAsset = this._wrappedAsset.addRawAmount(rawAmount);
+        return this;
+    }
+    async getEVMAddress() {
+        return this._evmAddress;
+    }
+    async getTVMAddress() {
+        return this.address;
+    }
+    generatePayload(params) {
+        return this._wrappedAsset.generatePayload(params);
+    }
+    async checkCanBeTransferredBy(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if ((await this.getBalanceOf(userAddress, blockchainType)) < this.rawAmount) {
+            throw (0, errors_1.insufficientBalanceError)(this.address);
+        }
+    }
+    async getBalanceOf(userAddress, blockchainType = Struct_1.BlockchainType.TON) {
+        if (blockchainType === Struct_1.BlockchainType.TAC) {
+            Validator_1.Validator.validateEVMAddress(userAddress);
+            return this._configuration.TACParams.provider.getBalance(userAddress);
+        }
+        return this._wrappedAsset.getBalanceOf(userAddress, blockchainType);
+    }
+}
+exports.TAC = TAC;

package/dist/src/assets/TON.d.ts

@@ -2,7 +2,7 @@ import { Cell } from '@ton/ton';
 import { Asset, IConfiguration } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
 import type { ShardTransaction } from '../structs/InternalStruct';
-import { AssetType, FeeParams, Origin } from '../structs/Struct';
+import { AssetType, BlockchainType, FeeParams, Origin } from '../structs/Struct';
 export declare class TON implements Asset {
     readonly address: string;
     readonly type: AssetType;
@@ -29,6 +29,6 @@ export declare class TON implements Asset {
     }): Cell;
     getUserBalance(userAddress: string): Promise<bigint>;
     static checkBalance(sender: SenderAbstraction, config: IConfiguration, transactions: ShardTransaction[]): Promise<void>;
-    checkCanBeTransferredBy(userAddress: string): Promise<void>;
-    getBalanceOf(userAddress: string): Promise<bigint>;
+    checkCanBeTransferredBy(userAddress: string, blockchainType?: BlockchainType): Promise<void>;
+    getBalanceOf(userAddress: string, blockchainType?: BlockchainType): Promise<bigint>;
 }