@tonappchain/sdk 0.6.5-mainnet-alpha → 0.7.0-rc7

package/dist/adapters/contractOpener.d.ts

@@ -1,5 +1,5 @@
-import { ContractOpener, Network } from '../structs/Struct';
 import { Blockchain } from '@ton/sandbox';
+import { ContractOpener, Network } from '../structs/Struct';
 type LiteServer = {
     ip: number;
     port: number;

package/dist/adapters/contractOpener.js

@@ -4,16 +4,16 @@ exports.liteClientOpener = liteClientOpener;
 exports.sandboxOpener = sandboxOpener;
 exports.orbsOpener = orbsOpener;
 exports.orbsOpener4 = orbsOpener4;
-const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
-const Struct_1 = require("../structs/Struct");
 const ton_access_1 = require("@orbs-network/ton-access");
 const ton_1 = require("@ton/ton");
 const artifacts_1 = require("@tonappchain/artifacts");
+const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
+const Struct_1 = require("../structs/Struct");
 function intToIP(int) {
-    var part1 = int & 255;
-    var part2 = (int >> 8) & 255;
-    var part3 = (int >> 16) & 255;
-    var part4 = (int >> 24) & 255;
+    const part1 = int & 255;
+    const part2 = (int >> 8) & 255;
+    const part3 = (int >> 16) & 255;
+    const part4 = (int >> 24) & 255;
     return part4 + '.' + part3 + '.' + part2 + '.' + part1;
 }
 async function getDefaultLiteServers(network) {
@@ -70,8 +70,7 @@ async function orbsOpener(network) {
     const endpoint = await (0, ton_access_1.getHttpEndpoint)({
         network,
     });
-    const client = new ton_1.TonClient({ endpoint });
-    return client;
+    return new ton_1.TonClient({ endpoint });
 }
 async function orbsOpener4(network, timeout = 10000) {
     const endpoint = await (0, ton_access_1.getHttpV4Endpoint)({ network });

package/dist/adapters/retryableContractOpener.d.ts

@@ -0,0 +1,21 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Address, Contract, OpenedContract } from '@ton/ton';
+import { mainnet, testnet } from '@tonappchain/artifacts';
+import { ContractOpener, ContractState } from '../structs/Struct';
+export interface OpenerConfig {
+    opener: ContractOpener;
+    retries: number;
+    retryDelay: number;
+}
+export declare class RetryableContractOpener implements ContractOpener {
+    private readonly openerConfigs;
+    constructor(openerConfigs: OpenerConfig[]);
+    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    closeConnections(): void;
+    private executeWithFallback;
+    private tryWithRetries;
+    private createRetryableContract;
+    private callMethodAcrossOpeners;
+}
+export declare function createDefaultRetryableOpener(artifacts: typeof testnet | typeof mainnet, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/adapters/retryableContractOpener.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryableContractOpener = void 0;
+exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
+const ton_1 = require("@ton/ton");
+const artifacts_1 = require("@tonappchain/artifacts");
+const instances_1 = require("../errors/instances");
+const Struct_1 = require("../structs/Struct");
+const contractOpener_1 = require("./contractOpener");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryableContractOpener {
+    constructor(openerConfigs) {
+        if (openerConfigs.length === 0) {
+            throw new Error('No ContractOpener instances available');
+        }
+        this.openerConfigs = openerConfigs;
+    }
+    open(src) {
+        const firstConfig = this.openerConfigs[0];
+        const contract = firstConfig.opener.open(src);
+        return this.createRetryableContract(contract, src);
+    }
+    async getContractState(address) {
+        const result = await this.executeWithFallback((config) => config.opener.getContractState(address));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
+    }
+    closeConnections() {
+        for (const config of this.openerConfigs) {
+            config.opener.closeConnections?.();
+        }
+    }
+    async executeWithFallback(operation) {
+        let lastError;
+        for (const config of this.openerConfigs) {
+            const result = await this.tryWithRetries(() => operation(config), config);
+            if (result.success) {
+                return { success: true, data: result.data };
+            }
+            lastError = result.lastError;
+        }
+        return { success: false, lastError };
+    }
+    async tryWithRetries(operation, config) {
+        let lastError;
+        for (let attempt = 0; attempt <= config.retries; attempt++) {
+            try {
+                const data = await operation();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < config.retries) {
+                    await sleep(config.retryDelay);
+                }
+            }
+        }
+        return { success: false, lastError };
+    }
+    createRetryableContract(contract, src) {
+        return new Proxy(contract, {
+            get: (target, prop) => {
+                const value = Reflect.get(target, prop);
+                if (typeof value !== 'function')
+                    return value;
+                return async (...args) => {
+                    return this.callMethodAcrossOpeners(prop, args, src);
+                };
+            },
+        });
+    }
+    async callMethodAcrossOpeners(methodName, args, src) {
+        const result = await this.executeWithFallback((config) => {
+            const contract = config.opener.open(src);
+            const method = Reflect.get(contract, methodName);
+            if (typeof method !== 'function') {
+                throw new Error(`Method ${String(methodName)} is not a function`);
+            }
+            return method.call(contract, ...args);
+        });
+        if (result.success)
+            return result.data;
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('failed to call method in contract');
+    }
+}
+exports.RetryableContractOpener = RetryableContractOpener;
+async function createDefaultRetryableOpener(artifacts, maxRetries = 3, retryDelay = 1000) {
+    const tonClient = new ton_1.TonClient({
+        endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString(),
+    });
+    const network = artifacts === artifacts_1.testnet ? Struct_1.Network.TESTNET : Struct_1.Network.MAINNET;
+    const opener4 = await (0, contractOpener_1.orbsOpener4)(network);
+    const opener = await (0, contractOpener_1.orbsOpener)(network);
+    return new RetryableContractOpener([
+        { opener: tonClient, retries: maxRetries, retryDelay },
+        { opener: opener4, retries: maxRetries, retryDelay },
+        { opener: opener, retries: maxRetries, retryDelay },
+    ]);
+}

package/dist/assets/AssetCache.d.ts

@@ -0,0 +1,23 @@
+import { Asset } from '../structs/Struct';
+export declare class AssetCache {
+    private static readonly cache;
+    /**
+     * Get asset from cache
+     */
+    static get(token: {
+        address: string;
+        index?: bigint;
+    }): Asset | undefined;
+    /**
+     * Set asset in cache
+     */
+    static set(token: {
+        address: string;
+        index?: bigint;
+    }, asset: Asset): void;
+    /**
+     * Clear the cache
+     */
+    static clear(): void;
+    private static generateKey;
+}

package/dist/assets/AssetCache.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetCache = void 0;
+class AssetCache {
+    /**
+     * Get asset from cache
+     */
+    static get(token) {
+        const key = this.generateKey(token);
+        return this.cache.get(key);
+    }
+    /**
+     * Set asset in cache
+     */
+    static set(token, asset) {
+        const key = this.generateKey(token);
+        this.cache.set(key, asset);
+    }
+    /**
+     * Clear the cache
+     */
+    static clear() {
+        this.cache.clear();
+    }
+    static generateKey(token) {
+        // Normalize address to lowercase for consistency
+        const normalizedAddress = token.address.toLowerCase();
+        const parts = [normalizedAddress];
+        if (token.index !== undefined) {
+            parts.push(token.index.toString());
+        }
+        return parts.join('|');
+    }
+}
+exports.AssetCache = AssetCache;
+AssetCache.cache = new Map();

package/dist/assets/AssetFactory.d.ts

@@ -0,0 +1,19 @@
+import { IConfiguration } from '../structs/Services';
+import { Asset, AssetType, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
+export declare class AssetFactory {
+    static from(configuration: IConfiguration, token: {
+        address: TVMAddress | EVMAddress;
+        tokenType: AssetType.FT;
+    } | {
+        address: TVMAddress | EVMAddress;
+        tokenType: AssetType.NFT;
+        addressType: NFTAddressType.COLLECTION;
+        index: bigint;
+    } | {
+        address: TVMAddress;
+        tokenType: AssetType.NFT;
+        addressType: NFTAddressType.ITEM;
+    }): Promise<Asset>;
+    private static createFTAsset;
+    private static createNFTAsset;
+}

package/dist/assets/AssetFactory.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetFactory = void 0;
+const errors_1 = require("../errors");
+const Struct_1 = require("../structs/Struct");
+const AssetCache_1 = require("./AssetCache");
+const FT_1 = require("./FT");
+const NFT_1 = require("./NFT");
+const TON_1 = require("./TON");
+class AssetFactory {
+    /// PUBLIC
+    static async from(configuration, token) {
+        if (token.address === '' || token.address === configuration.nativeTONAddress) {
+            return TON_1.TON.create(configuration);
+        }
+        const cachedAsset = AssetCache_1.AssetCache.get(token);
+        if (cachedAsset) {
+            return cachedAsset.clone.withAmount({ rawAmount: 0n });
+        }
+        const asset = token.tokenType === Struct_1.AssetType.FT
+            ? await this.createFTAsset(configuration, token.address)
+            : await this.createNFTAsset(configuration, token.address, token.addressType, token.addressType === Struct_1.NFTAddressType.COLLECTION ? token.index : undefined);
+        AssetCache_1.AssetCache.set(token, asset);
+        return asset;
+    }
+    /// PRIVATE
+    /// CREATE FT ASSET
+    static async createFTAsset(configuration, address) {
+        return FT_1.FT.fromAddress(configuration, address);
+    }
+    /// CREATE NFT ASSET
+    static async createNFTAsset(configuration, address, addressType, index) {
+        if (addressType === Struct_1.NFTAddressType.ITEM) {
+            return NFT_1.NFT.fromItem(configuration, address);
+        }
+        if (addressType === Struct_1.NFTAddressType.COLLECTION) {
+            if (!index) {
+                throw (0, errors_1.indexRequiredError)(address);
+            }
+            return NFT_1.NFT.fromCollection(configuration, { collection: address, index });
+        }
+        throw (0, errors_1.unknownTokenTypeError)(address, 'NFT address type is unknown: should be either ITEM or COLLECTION');
+    }
+}
+exports.AssetFactory = AssetFactory;

package/dist/assets/FT.d.ts

@@ -0,0 +1,55 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Cell, OpenedContract } from '@ton/ton';
+import { AssetOpType } from '../structs/InternalStruct';
+import { IConfiguration } from '../structs/Services';
+import { AssetType, ContractOpener, EVMAddress, FeeParams, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { Asset, Origin } from '../structs/Struct';
+import { JettonWallet } from '../wrappers/JettonWallet';
+export declare class FT implements Asset {
+    private _tokenAddress;
+    readonly type: AssetType;
+    readonly origin: Origin;
+    private _configuration;
+    private _jettonMinter;
+    private _decimals?;
+    private _transferAmount;
+    private _evmAddress?;
+    get address(): string;
+    static getJettonData(contractOpener: ContractOpener, address: TVMAddress): Promise<import("../wrappers/JettonMaster").JettonMasterData>;
+    static getOrigin(configuration: IConfiguration, address: TVMAddress): Promise<Origin>;
+    static getTVMAddress(configuration: IConfiguration, address: EVMAddress): Promise<string>;
+    private constructor();
+    static fromAddress(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<FT>;
+    get rawAmount(): bigint;
+    get clone(): FT;
+    withAmount(amount: {
+        rawAmount: bigint;
+    } | {
+        amount: number;
+    }): Promise<FT>;
+    addAmount(amount: {
+        rawAmount: bigint;
+    } | {
+        amount: number;
+    }): Promise<FT>;
+    getDecimals(): Promise<number>;
+    getEVMAddress(): Promise<string>;
+    getTVMAddress(): Promise<string>;
+    generatePayload(params: {
+        excessReceiver: string;
+        evmData: Cell;
+        crossChainTonAmount?: bigint;
+        forwardFeeTonAmount?: bigint;
+        feeParams?: FeeParams;
+    }): Promise<Cell>;
+    get opType(): AssetOpType.JETTON_BURN | AssetOpType.JETTON_TRANSFER;
+    getWallet(userAddress: string): Promise<OpenedContract<JettonWallet> | SandboxContract<JettonWallet>>;
+    getUserWalletAddress(userAddress: string): Promise<string>;
+    getUserBalance(userAddress: string): Promise<bigint>;
+    getUserBalanceExtended(userAddress: string): Promise<UserWalletBalanceExtended>;
+    checkBalance(userAddress: string): Promise<void>;
+    checkCanBeTransferedBy(userAddress: string): Promise<void>;
+    getBalanceOf(userAddress: string): Promise<bigint>;
+    private getTransferPayload;
+    private getBurnPayload;
+}

package/dist/assets/FT.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FT = void 0;
+const ton_1 = require("@ton/ton");
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+const Validator_1 = require("../sdk/Validator");
+const InternalStruct_1 = require("../structs/InternalStruct");
+const Struct_1 = require("../structs/Struct");
+const Struct_2 = require("../structs/Struct");
+const JettonMaster_1 = require("../wrappers/JettonMaster");
+const JettonWallet_1 = require("../wrappers/JettonWallet");
+class FT {
+    get address() {
+        return this._tokenAddress.toString();
+    }
+    static async getJettonData(contractOpener, address) {
+        Validator_1.Validator.validateTVMAddress(address);
+        const jetton = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
+        return await jetton.getJettonData();
+    }
+    static async getOrigin(configuration, address) {
+        const { jettonMinterCode, crossChainLayerAddress, jettonWalletCode } = configuration.TONParams;
+        const { code: thisCodeBOC } = await configuration.TONParams.contractOpener.getContractState(ton_1.Address.parse(address));
+        if (!thisCodeBOC) {
+            throw errors_1.emptyContractError;
+        }
+        const thisCode = ton_1.Cell.fromBoc(thisCodeBOC)[0];
+        if (!jettonMinterCode.equals(thisCode)) {
+            return Struct_2.Origin.TON;
+        }
+        const jettonMinter = configuration.TONParams.contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
+        const evmAddress = await jettonMinter.getEVMAddress();
+        const expectedMinterAddress = await (0, Utils_1.calculateContractAddress)(jettonMinterCode, (0, ton_1.beginCell)()
+            .storeCoins(0)
+            .storeAddress(ton_1.Address.parse(crossChainLayerAddress))
+            .storeAddress(null)
+            .storeRef((0, ton_1.beginCell)().endCell())
+            .storeRef(jettonWalletCode)
+            .storeStringTail(evmAddress)
+            .endCell());
+        if (!expectedMinterAddress.equals(ton_1.Address.parse(address))) {
+            return Struct_2.Origin.TON;
+        }
+        return Struct_2.Origin.TAC;
+    }
+    static async getTVMAddress(configuration, address) {
+        Validator_1.Validator.validateEVMAddress(address);
+        const exists = await configuration.TACParams.tokenUtils['exists(address)'](address);
+        if (exists) {
+            const erc20Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(address, configuration.TACParams.provider);
+            const info = await erc20Token.getInfo();
+            return info.tvmAddress;
+        }
+        const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
+            evmTokenAddress: address,
+            crossChainLayerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
+            code: configuration.TONParams.jettonMinterCode,
+            walletCode: configuration.TONParams.jettonWalletCode,
+        });
+        return jettonMaster.address.toString();
+    }
+    constructor(address, origin, configuration) {
+        this.type = Struct_1.AssetType.FT;
+        this._tokenAddress = ton_1.Address.parse(address);
+        this._configuration = configuration;
+        this._jettonMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(this._tokenAddress));
+        this.origin = origin;
+        this._transferAmount = 0n;
+    }
+    static async fromAddress(configuration, address) {
+        const tvmAddress = (0, ethers_1.isAddress)(address) ? await this.getTVMAddress(configuration, address) : address;
+        const origin = await FT.getOrigin(configuration, tvmAddress).catch((e) => {
+            if (e instanceof errors_1.ContractError) {
+                return Struct_2.Origin.TAC;
+            }
+            throw e;
+        });
+        return new FT(tvmAddress, origin, configuration);
+    }
+    get rawAmount() {
+        return this._transferAmount;
+    }
+    get clone() {
+        const ft = new FT(this._tokenAddress.toString(), this.origin, this._configuration);
+        ft._transferAmount = this._transferAmount;
+        ft._evmAddress = this._evmAddress;
+        ft._decimals = this._decimals;
+        return ft;
+    }
+    async withAmount(amount) {
+        if (this._transferAmount > 0n) {
+            // clone token if withAmount set before to avoid changing the original token
+            const newToken = this.clone;
+            newToken._transferAmount =
+                'rawAmount' in amount ? amount.rawAmount : (0, Utils_1.calculateRawAmount)(amount.amount, await this.getDecimals());
+            return newToken;
+        }
+        if ('rawAmount' in amount) {
+            this._transferAmount = amount.rawAmount;
+        }
+        else {
+            const decimals = await this.getDecimals();
+            this._transferAmount = (0, Utils_1.calculateRawAmount)(amount.amount, decimals);
+        }
+        return this;
+    }
+    async addAmount(amount) {
+        if ('rawAmount' in amount) {
+            this._transferAmount = this._transferAmount + amount.rawAmount;
+        }
+        else {
+            const decimals = await this.getDecimals();
+            this._transferAmount = this._transferAmount + (0, Utils_1.calculateRawAmount)(amount.amount, decimals);
+        }
+        return this;
+    }
+    async getDecimals() {
+        if (!this._decimals) {
+            const decimalsRaw = (await this._jettonMinter.getJettonData()).content.metadata.decimals;
+            this._decimals = decimalsRaw ? Number(decimalsRaw) : 9;
+        }
+        return this._decimals;
+    }
+    async getEVMAddress() {
+        if (this._evmAddress) {
+            return this._evmAddress;
+        }
+        if (this.origin === Struct_2.Origin.TAC) {
+            this._evmAddress = await this._jettonMinter.getEVMAddress();
+        }
+        else {
+            this._evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(this._tokenAddress.toString());
+        }
+        return this._evmAddress;
+    }
+    async getTVMAddress() {
+        return this._tokenAddress.toString();
+    }
+    async generatePayload(params) {
+        const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
+        const feeData = (0, Utils_1.generateFeeData)(feeParams);
+        let payload;
+        switch (this.opType) {
+            case InternalStruct_1.AssetOpType.JETTON_BURN:
+                payload = this.getBurnPayload(this._transferAmount, this._configuration.TONParams.crossChainLayerAddress, evmData, crossChainTonAmount, feeData);
+                break;
+            case InternalStruct_1.AssetOpType.JETTON_TRANSFER:
+                payload = this.getTransferPayload(this._transferAmount, this._configuration.TONParams.jettonProxyAddress, excessReceiver, evmData, crossChainTonAmount, forwardFeeTonAmount, feeData);
+                break;
+        }
+        return payload;
+    }
+    get opType() {
+        return this.origin === 'TAC' ? InternalStruct_1.AssetOpType.JETTON_BURN : InternalStruct_1.AssetOpType.JETTON_TRANSFER;
+    }
+    async getWallet(userAddress) {
+        const walletAddress = await this.getUserWalletAddress(userAddress);
+        return this._configuration.TONParams.contractOpener.open(JettonWallet_1.JettonWallet.createFromAddress(ton_1.Address.parse(walletAddress)));
+    }
+    async getUserWalletAddress(userAddress) {
+        return this._jettonMinter.getWalletAddress(userAddress);
+    }
+    async getUserBalance(userAddress) {
+        const wallet = await this.getWallet(userAddress);
+        return BigInt(await wallet.getJettonBalance());
+    }
+    async getUserBalanceExtended(userAddress) {
+        const masterState = await this._configuration.TONParams.contractOpener.getContractState(this._tokenAddress);
+        if (masterState.state !== 'active') {
+            return { exists: false };
+        }
+        const wallet = await this.getWallet(userAddress);
+        const rawAmount = await wallet.getJettonBalance();
+        const decimals = await this.getDecimals();
+        return {
+            rawAmount,
+            decimals,
+            amount: (0, Utils_1.calculateAmount)(rawAmount, decimals),
+            exists: true,
+        };
+    }
+    async checkBalance(userAddress) {
+        const balance = await this.getUserBalance(userAddress);
+        if (balance < this._transferAmount) {
+            throw (0, errors_1.insufficientBalanceError)(this._tokenAddress.toString());
+        }
+    }
+    async checkCanBeTransferedBy(userAddress) {
+        await this.checkBalance(userAddress);
+    }
+    async getBalanceOf(userAddress) {
+        return this.getUserBalance(userAddress);
+    }
+    getTransferPayload(rawAmount, notificationReceiverAddress, responseAddress, evmData, crossChainTonAmount, forwardFeeAmount, feeData) {
+        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
+        return JettonWallet_1.JettonWallet.transferMessage(rawAmount, notificationReceiverAddress, responseAddress, Consts_1.JETTON_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount, crossChainTonAmount, feeData, evmData, queryId);
+    }
+    getBurnPayload(rawAmount, notificationReceiverAddress, evmData, crossChainTonAmount, feeData) {
+        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
+        return JettonWallet_1.JettonWallet.burnMessage(rawAmount, notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
+    }
+}
+exports.FT = FT;

package/dist/assets/NFT.d.ts

@@ -0,0 +1,69 @@
+import { Address, Cell } from '@ton/ton';
+import { IConfiguration } from '../structs/Services';
+import { Asset, AssetType, ContractOpener, EVMAddress, FeeParams, NFTItemData, Origin, TVMAddress } from '../structs/Struct';
+export declare class NFT implements Asset {
+    private _addresses;
+    readonly origin: Origin;
+    readonly type: AssetType;
+    private _nftCollection;
+    private _configuration;
+    /**
+     * @description Create NFT from item address. Item MUST BE deployed on TON.
+     * @param configuration - Configuration
+     * @param item - Item address (TVM address)
+     * @param origin - Origin
+     * @returns NFT
+     */
+    static fromItem(configuration: IConfiguration, item: TVMAddress): Promise<NFT>;
+    /**
+     * @description Create NFT from collection address. TON-native assets MUST BE deployed on TON.
+     * @param configuration - Configuration
+     * @param item - Item address (TVM address)
+     * @param origin - Origin
+     * @returns NFT
+     */
+    static fromCollection(configuration: IConfiguration, item: {
+        collection: TVMAddress | EVMAddress;
+        index: bigint;
+    }): Promise<NFT>;
+    static getItemData(contractOpener: ContractOpener, itemAddress: TVMAddress): Promise<NFTItemData>;
+    static getCollectionData(contractOpener: ContractOpener, collectionAddress: TVMAddress): Promise<{
+        nextIndex: number;
+        content: Cell;
+        ownerAddress: Address;
+    }>;
+    static getOrigin(configuration: IConfiguration, itemOrCollection: TVMAddress): Promise<Origin>;
+    static getItemAddress(contractOpener: ContractOpener, collectionAddress: TVMAddress, index: bigint): Promise<string>;
+    static getTVMAddress(configuration: IConfiguration, collectionAddress: EVMAddress, tokenId?: bigint): Promise<string>;
+    constructor(nftAddress: {
+        item: TVMAddress;
+        collection: TVMAddress;
+        index: bigint;
+        evmAddress?: EVMAddress;
+    }, origin: Origin, configuration: IConfiguration);
+    get addresses(): {
+        item: string;
+        collection: string;
+        index: bigint;
+        evmAddress?: string;
+    };
+    get address(): string;
+    get rawAmount(): bigint;
+    get clone(): NFT;
+    withAmount(): Promise<NFT>;
+    addAmount(): Promise<NFT>;
+    getEVMAddress(): Promise<string>;
+    getTVMAddress(): Promise<string>;
+    generatePayload(params: {
+        excessReceiver: string;
+        evmData: Cell;
+        crossChainTonAmount?: bigint;
+        forwardFeeTonAmount?: bigint;
+        feeParams?: FeeParams;
+    }): Promise<Cell>;
+    isOwnedBy(userAddress: string): Promise<boolean>;
+    checkCanBeTransferedBy(userAddress: string): Promise<void>;
+    getBalanceOf(userAddress: string): Promise<bigint>;
+    private getBurnPayload;
+    private getTransferPayload;
+}