@tonappchain/sdk 0.6.6-mainnet-alpha → 0.7.0-rc11

package/dist/assets/FT.d.ts

@@ -0,0 +1,58 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Cell, OpenedContract } from '@ton/ton';
+import { AssetOpType } from '../structs/InternalStruct';
+import { Asset, IConfiguration, ContractOpener } from '../interfaces';
+import { AssetType, EVMAddress, FeeParams, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { Origin } from '../structs/Struct';
+import { JettonMasterData } from '../wrappers/JettonMaster';
+import { JettonWallet } from '../wrappers/JettonWallet';
+export declare class FT implements Asset {
+    private _tvmAddress;
+    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<JettonMasterData>;
+    getJettonData(): Promise<JettonMasterData>;
+    static getOrigin(configuration: IConfiguration, address: TVMAddress): Promise<Origin>;
+    static getTVMAddress(configuration: IConfiguration, address: EVMAddress): Promise<string>;
+    static getEVMAddress(configuration: IConfiguration, address: TVMAddress): 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>;
+    checkCanBeTransferredBy(userAddress: string): Promise<void>;
+    getBalanceOf(userAddress: string): Promise<bigint>;
+    private getTransferPayload;
+    private getBurnPayload;
+}

package/dist/assets/FT.js

@@ -0,0 +1,231 @@
+"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._tvmAddress.toString({ bounceable: true });
+    }
+    static async getJettonData(contractOpener, address) {
+        Validator_1.Validator.validateTVMAddress(address);
+        const jetton = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
+        return jetton.getJettonData();
+    }
+    async getJettonData() {
+        return FT.getJettonData(this._configuration.TONParams.contractOpener, this._tvmAddress.toString());
+    }
+    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);
+        // If token is TON native
+        const fromTVM = await configuration.TACParams.tokenUtils['exists(address)'](address);
+        if (fromTVM) {
+            const erc20Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(address, configuration.TACParams.provider);
+            const info = await erc20Token.getInfo();
+            return info.tvmAddress;
+        }
+        // If token is TAC native
+        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();
+    }
+    static async getEVMAddress(configuration, address) {
+        const tokenAddressString = ton_1.Address.parse(address).toString({ bounceable: true });
+        const origin = await FT.getOrigin(configuration, address);
+        if (origin === Struct_2.Origin.TON) {
+            return configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
+        }
+        else {
+            const givenMinter = configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddressString)));
+            return givenMinter.getEVMAddress();
+        }
+    }
+    constructor(address, origin, configuration) {
+        this.type = Struct_1.AssetType.FT;
+        this._tvmAddress = ton_1.Address.parse(address);
+        this._configuration = configuration;
+        this._jettonMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(this._tvmAddress));
+        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;
+        });
+        const token = new FT(tvmAddress, origin, configuration);
+        if ((0, ethers_1.isAddress)(address)) {
+            token._evmAddress = address;
+        }
+        return token;
+    }
+    get rawAmount() {
+        return this._transferAmount;
+    }
+    get clone() {
+        const ft = new FT(this._tvmAddress.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;
+        }
+        const tokenAddressString = this._tvmAddress.toString({ bounceable: true });
+        if (this.origin === Struct_2.Origin.TON) {
+            this._evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
+        }
+        else if (this.origin === Struct_2.Origin.TAC) {
+            const givenMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddressString)));
+            this._evmAddress = await givenMinter.getEVMAddress();
+        }
+        else {
+            throw (0, errors_1.unknownTokenTypeError)(tokenAddressString, 'Token origin is neither TON nor TAC');
+        }
+        return this._evmAddress;
+    }
+    async getTVMAddress() {
+        return this._tvmAddress.toString({ bounceable: true });
+    }
+    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 === Struct_2.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._tvmAddress);
+        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._tvmAddress.toString());
+        }
+    }
+    async checkCanBeTransferredBy(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,65 @@
+import { Cell } from '@ton/ton';
+import { Asset, IConfiguration, ContractOpener } from '../interfaces';
+import { AssetType, EVMAddress, FeeParams, NFTCollectionData, 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)
+     * @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)
+     * @returns NFT
+     */
+    static fromCollection(configuration: IConfiguration, item: {
+        collection: TVMAddress | EVMAddress;
+        index: bigint;
+    }): Promise<NFT>;
+    static getItemData(contractOpener: ContractOpener, itemAddress: TVMAddress): Promise<NFTItemData>;
+    getItemData(): Promise<NFTItemData>;
+    static getCollectionData(contractOpener: ContractOpener, collectionAddress: TVMAddress): Promise<NFTCollectionData>;
+    getCollectionData(): Promise<NFTCollectionData>;
+    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>;
+    checkCanBeTransferredBy(userAddress: string): Promise<void>;
+    getBalanceOf(userAddress: string): Promise<bigint>;
+    private getBurnPayload;
+    private getTransferPayload;
+}

package/dist/assets/NFT.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFT = void 0;
+const ton_1 = require("@ton/ton");
+const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
+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");
+class NFT {
+    /**
+     * @description Create NFT from item address. Item MUST BE deployed on TON.
+     * @param configuration - Configuration
+     * @param item - Item address (TVM address)
+     * @returns NFT
+     */
+    static async fromItem(configuration, item) {
+        Validator_1.Validator.validateTVMAddress(item);
+        const nftItem = configuration.TONParams.contractOpener.open(wrappers_1.NFTItem.createFromAddress(ton_1.Address.parse(item)));
+        const { collectionAddress, index } = await nftItem.getNFTData();
+        const origin = await NFT.getOrigin(configuration, item);
+        return new NFT({ item, collection: collectionAddress.toString(), index: BigInt(index) }, origin, configuration);
+    }
+    /**
+     * @description Create NFT from collection address. TON-native assets MUST BE deployed on TON.
+     * @param configuration - Configuration
+     * @param item - Item address (TVM address)
+     * @returns NFT
+     */
+    static async fromCollection(configuration, item) {
+        const tvmCollectionAddress = (0, ethers_1.isAddress)(item.collection)
+            ? await this.getTVMAddress(configuration, item.collection)
+            : item.collection;
+        const origin = await NFT.getOrigin(configuration, tvmCollectionAddress).catch((e) => {
+            if (e instanceof errors_1.ContractError) {
+                return Struct_1.Origin.TAC;
+            }
+            throw e;
+        });
+        const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(tvmCollectionAddress)));
+        const itemAddress = origin === Struct_1.Origin.TAC
+            ? wrappers_1.NFTItem.createFromConfig({
+                collectionAddress: nftCollection.address,
+                cclAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
+                // @ts-expect-error // bigint can be used, wrapper is not typed properly
+                index: item.index,
+            }, configuration.TONParams.nftItemCode).address
+            : await nftCollection.getNFTAddressByIndex(item.index);
+        return new NFT({
+            item: itemAddress.toString(),
+            collection: tvmCollectionAddress,
+            index: item.index,
+            evmAddress: (0, ethers_1.isAddress)(item.collection) ? item.collection : undefined,
+        }, origin, configuration);
+    }
+    static async getItemData(contractOpener, itemAddress) {
+        Validator_1.Validator.validateTVMAddress(itemAddress);
+        const nftItem = contractOpener.open(wrappers_1.NFTItem.createFromAddress(ton_1.Address.parse(itemAddress)));
+        return nftItem.getNFTData();
+    }
+    async getItemData() {
+        return NFT.getItemData(this._configuration.TONParams.contractOpener, this._addresses.item);
+    }
+    static async getCollectionData(contractOpener, collectionAddress) {
+        Validator_1.Validator.validateTVMAddress(collectionAddress);
+        const nftCollection = contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(collectionAddress)));
+        return nftCollection.getCollectionData();
+    }
+    async getCollectionData() {
+        return NFT.getCollectionData(this._configuration.TONParams.contractOpener, this._addresses.collection);
+    }
+    static async getOrigin(configuration, itemOrCollection) {
+        const { nftItemCode, nftCollectionCode } = configuration.TONParams;
+        const { code: givenCodeBOC } = await configuration.TONParams.contractOpener.getContractState(ton_1.Address.parse(itemOrCollection));
+        if (!givenCodeBOC) {
+            throw errors_1.emptyContractError;
+        }
+        const givenNFTCode = ton_1.Cell.fromBoc(givenCodeBOC)[0];
+        if (nftItemCode.equals(givenNFTCode) || nftCollectionCode.equals(givenNFTCode)) {
+            return Struct_1.Origin.TAC;
+        }
+        return Struct_1.Origin.TON;
+    }
+    static async getItemAddress(contractOpener, collectionAddress, index) {
+        Validator_1.Validator.validateTVMAddress(collectionAddress);
+        const nftCollection = contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(collectionAddress)));
+        const address = await nftCollection.getNFTAddressByIndex(index);
+        return address.toString();
+    }
+    static async getTVMAddress(configuration, collectionAddress, tokenId) {
+        Validator_1.Validator.validateEVMAddress(collectionAddress);
+        const exists = await configuration.TACParams.tokenUtils['exists(address)'](collectionAddress);
+        if (exists) {
+            const erc721Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC721FactoryTAC.connect(collectionAddress, configuration.TACParams.provider);
+            const info = await erc721Token.getInfo();
+            const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(info.tvmAddress)));
+            return tokenId == undefined
+                ? nftCollection.address.toString()
+                : (await nftCollection.getNFTAddressByIndex(tokenId)).toString();
+        }
+        else {
+            const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
+                adminAddress: (0, ton_1.address)(configuration.TONParams.crossChainLayerAddress),
+                newAdminAddress: null,
+                collectionContent: (0, ton_1.beginCell)().endCell(),
+                commonContent: (0, ton_1.beginCell)().endCell(),
+                nftItemCode: configuration.TONParams.nftItemCode,
+                originalAddress: collectionAddress,
+            }, configuration.TONParams.nftCollectionCode));
+            return tokenId == undefined
+                ? nftCollection.address.toString()
+                : wrappers_1.NFTItem.createFromConfig({
+                    collectionAddress: nftCollection.address,
+                    cclAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
+                    // @ts-expect-error // bigint can be used, wrapper is not typed properly
+                    index: tokenId,
+                }, configuration.TONParams.nftItemCode).address.toString();
+        }
+    }
+    constructor(nftAddress, origin, configuration) {
+        this.type = Struct_1.AssetType.NFT;
+        this._addresses = nftAddress;
+        this._configuration = configuration;
+        this.origin = origin;
+        this._nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(this._addresses.collection)));
+    }
+    get addresses() {
+        return this._addresses;
+    }
+    get address() {
+        return this._addresses.item;
+    }
+    get rawAmount() {
+        return 1n;
+    }
+    get clone() {
+        return new NFT(this._addresses, this.origin, this._configuration);
+    }
+    async withAmount() {
+        return this;
+    }
+    async addAmount() {
+        return this;
+    }
+    async getEVMAddress() {
+        if (this._addresses.evmAddress) {
+            return this._addresses.evmAddress;
+        }
+        const tvmNFTAddress = ton_1.Address.parse(this._addresses.collection).toString({ bounceable: true });
+        const { code: givenNFTCollection } = await this._configuration.TONParams.contractOpener.getContractState(ton_1.Address.parse(tvmNFTAddress));
+        if (givenNFTCollection &&
+            this._configuration.TONParams.nftCollectionCode.equals(ton_1.Cell.fromBoc(givenNFTCollection)[0])) {
+            const nftCollection = this._configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(tvmNFTAddress)));
+            const evmAddress = await nftCollection.getOriginalAddress();
+            this._addresses.evmAddress = evmAddress.toString();
+        }
+        else {
+            this._addresses.evmAddress =
+                await this._configuration.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
+        }
+        return this._addresses.evmAddress;
+    }
+    async getTVMAddress() {
+        return this.address.toString();
+    }
+    async generatePayload(params) {
+        const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
+        const opType = this.origin === Struct_1.Origin.TAC ? InternalStruct_1.AssetOpType.NFT_BURN : InternalStruct_1.AssetOpType.NFT_TRANSFER;
+        const feeData = (0, Utils_1.generateFeeData)(feeParams);
+        let payload;
+        switch (opType) {
+            case InternalStruct_1.AssetOpType.NFT_BURN:
+                payload = this.getBurnPayload(this._configuration.TONParams.crossChainLayerAddress, evmData, crossChainTonAmount, feeData);
+                break;
+            case InternalStruct_1.AssetOpType.NFT_TRANSFER:
+                payload = this.getTransferPayload(this._configuration.TONParams.nftProxyAddress, excessReceiver, forwardFeeTonAmount, evmData, crossChainTonAmount, feeData);
+                break;
+        }
+        return payload;
+    }
+    async isOwnedBy(userAddress) {
+        const nftData = await NFT.getItemData(this._configuration.TONParams.contractOpener, this.address.toString());
+        return !!nftData.ownerAddress?.equals(ton_1.Address.parse(userAddress));
+    }
+    async checkCanBeTransferredBy(userAddress) {
+        if (!(await this.isOwnedBy(userAddress))) {
+            throw (0, errors_1.insufficientBalanceError)(this.address.toString());
+        }
+    }
+    async getBalanceOf(userAddress) {
+        return (await this.isOwnedBy(userAddress)) ? 1n : 0n;
+    }
+    getBurnPayload(crossChainLayerAddress, evmData, crossChainTonAmount, feeData) {
+        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
+        return wrappers_1.NFTItem.burnMessage(queryId, (0, ton_1.address)(crossChainLayerAddress), crossChainTonAmount, evmData, feeData);
+    }
+    getTransferPayload(to, responseAddress, forwardFeeAmount, evmData, crossChainTonAmount, feeData) {
+        const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
+        const forwardPayload = (0, ton_1.beginCell)()
+            .storeCoins(crossChainTonAmount)
+            .storeMaybeRef(feeData)
+            .storeMaybeRef(evmData)
+            .endCell();
+        return wrappers_1.NFTItem.transferMessage(queryId, (0, ton_1.address)(to), (0, ton_1.address)(responseAddress), Number((0, ton_1.fromNano)(Consts_1.NFT_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount)), forwardPayload);
+    }
+}
+exports.NFT = NFT;

package/dist/assets/TON.d.ts

@@ -0,0 +1,38 @@
+import { Cell } from '@ton/ton';
+import type { SenderAbstraction } from '../sender';
+import type { ShardTransaction } from '../structs/InternalStruct';
+import { Asset, IConfiguration } from '../interfaces';
+import { AssetType, FeeParams } from '../structs/Struct';
+export declare class TON implements Asset {
+    readonly address: string;
+    readonly type: AssetType;
+    private _rawAmount;
+    private _config;
+    constructor(config: IConfiguration);
+    static create(config: IConfiguration): TON;
+    get rawAmount(): bigint;
+    get clone(): TON;
+    withAmount(amount: {
+        rawAmount: bigint;
+    } | {
+        amount: number;
+    }): Promise<TON>;
+    addAmount(amount: {
+        rawAmount: bigint;
+    } | {
+        amount: number;
+    }): Promise<TON>;
+    getEVMAddress(): Promise<string>;
+    getTVMAddress(): Promise<string>;
+    generatePayload(params: {
+        excessReceiver: string;
+        evmData: Cell;
+        crossChainTonAmount?: bigint;
+        forwardFeeTonAmount?: bigint;
+        feeParams?: FeeParams;
+    }): Promise<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>;
+}