@tonappchain/sdk 0.7.0-rc6 → 0.7.0-rc7.1

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

@@ -1,13 +1,19 @@
 import { IConfiguration } from '../structs/Services';
-import { Asset, AssetType, ContractOpener, NFTAddressType } from '../structs/Struct';
+import { Asset, AssetType, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
 export declare class AssetFactory {
-    static getType(contractOpener: ContractOpener, address: string): Promise<{
-        type: AssetType;
-        addressType?: NFTAddressType;
-    }>;
     static from(configuration: IConfiguration, token: {
-        address: string;
-        index?: bigint;
-        tokenType?: AssetType;
+        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

@@ -1,73 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetFactory = void 0;
-const ethers_1 = require("ethers");
 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 {
-    static async getType(contractOpener, address) {
-        try {
-            await FT_1.FT.getJettonData(contractOpener, address);
-            return { type: Struct_1.AssetType.FT };
-        }
-        catch {
-            // not jetton
-        }
-        try {
-            await NFT_1.NFT.getItemData(contractOpener, address);
-            return { type: Struct_1.AssetType.NFT, addressType: Struct_1.NFTAddressType.ITEM };
-        }
-        catch {
-            // not nft item
-        }
-        try {
-            await NFT_1.NFT.getCollectionData(contractOpener, address);
-            return { type: Struct_1.AssetType.NFT, addressType: Struct_1.NFTAddressType.COLLECTION };
-        }
-        catch {
-            // not nft collection
-        }
-        throw (0, errors_1.unknownTokenTypeError)(address);
-    }
+    /// PUBLIC
     static async from(configuration, token) {
-        if ((0, ethers_1.isAddress)(token.address)) {
-            if (!token.tokenType) {
-                // cannot detect token type for evm address yet
-                throw (0, errors_1.unknownTokenTypeError)(token.address);
-            }
-            if (token.tokenType === Struct_1.AssetType.FT) {
-                token.address = await FT_1.FT.getTVMAddress(configuration, token.address);
-            }
-            if (token.tokenType === Struct_1.AssetType.NFT) {
-                token.address = await NFT_1.NFT.getTVMAddress(configuration, token.address, token.index);
-            }
-        }
-        if (!token.address || token.address === configuration.nativeTONAddress) {
+        if (token.address === '' || token.address === configuration.nativeTONAddress) {
             return TON_1.TON.create(configuration);
         }
-        const { type, addressType } = await this.getType(configuration.TONParams.contractOpener, token.address);
-        if (type === Struct_1.AssetType.FT) {
-            const origin = await FT_1.FT.getOrigin(configuration.TONParams.contractOpener, token.address, configuration);
-            return new FT_1.FT(token.address, origin, configuration);
+        const cachedAsset = AssetCache_1.AssetCache.get(token);
+        if (cachedAsset) {
+            return cachedAsset.clone.withAmount({ rawAmount: 0n });
         }
-        if (type === Struct_1.AssetType.NFT) {
-            if (addressType === Struct_1.NFTAddressType.ITEM) {
-                const origin = await NFT_1.NFT.getOrigin(configuration.TONParams.contractOpener, token.address, configuration);
-                return NFT_1.NFT.fromItem(configuration, token.address, origin);
-            }
-            if (addressType === Struct_1.NFTAddressType.COLLECTION) {
-                if (!token.index) {
-                    throw (0, errors_1.indexRequiredError)(token.address);
-                }
-                const itemAddress = await NFT_1.NFT.getItemAddress(configuration.TONParams.contractOpener, token.address, token.index);
-                const origin = await NFT_1.NFT.getOrigin(configuration.TONParams.contractOpener, itemAddress, configuration);
-                return NFT_1.NFT.fromCollection(configuration, { collection: token.address, index: token.index }, origin);
+        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 === undefined) {
+                throw (0, errors_1.indexRequiredError)(address);
             }
+            return NFT_1.NFT.fromCollection(configuration, { collection: address, index });
         }
-        throw (0, errors_1.unknownTokenTypeError)(token.address);
+        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

@@ -2,7 +2,7 @@ import { SandboxContract } from '@ton/sandbox';
 import { Cell, OpenedContract } from '@ton/ton';
 import { AssetOpType } from '../structs/InternalStruct';
 import { IConfiguration } from '../structs/Services';
-import { AssetType, ContractOpener, FeeParams, UserWalletBalanceExtended } from '../structs/Struct';
+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 {
@@ -14,15 +14,12 @@ export declare class FT implements Asset {
     private _decimals?;
     private _transferAmount;
     private _evmAddress?;
-    get addresses(): {
-        tvmAddress: string;
-        evmAddress?: string;
-    };
     get address(): string;
-    static getJettonData(contractOpener: ContractOpener, tvmAddress: string): Promise<import("../wrappers/JettonMaster").JettonMasterData>;
-    static getOrigin(contractOpener: ContractOpener, address: string, configuration: IConfiguration): Promise<Origin>;
-    static getTVMAddress(configuration: IConfiguration, evmAddress: string): Promise<string>;
-    constructor(tvmTokenAddress: string, origin: Origin, configuration: IConfiguration);
+    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: {
@@ -45,7 +42,7 @@ export declare class FT implements Asset {
         forwardFeeTonAmount?: bigint;
         feeParams?: FeeParams;
     }): Promise<Cell>;
-    getOpType(): Promise<AssetOpType.JETTON_BURN | AssetOpType.JETTON_TRANSFER>;
+    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>;

package/dist/assets/FT.js

@@ -2,6 +2,7 @@
 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");
@@ -12,20 +13,17 @@ const Struct_2 = require("../structs/Struct");
 const JettonMaster_1 = require("../wrappers/JettonMaster");
 const JettonWallet_1 = require("../wrappers/JettonWallet");
 class FT {
-    get addresses() {
-        return { tvmAddress: this._tokenAddress.toString(), evmAddress: this._evmAddress };
-    }
     get address() {
         return this._tokenAddress.toString();
     }
-    static async getJettonData(contractOpener, tvmAddress) {
-        Validator_1.Validator.validateTVMAddress(tvmAddress);
-        const jetton = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(tvmAddress)));
+    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(contractOpener, address, configuration) {
+    static async getOrigin(configuration, address) {
         const { jettonMinterCode, crossChainLayerAddress, jettonWalletCode } = configuration.TONParams;
-        const { code: thisCodeBOC } = await contractOpener.getContractState(ton_1.Address.parse(address));
+        const { code: thisCodeBOC } = await configuration.TONParams.contractOpener.getContractState(ton_1.Address.parse(address));
         if (!thisCodeBOC) {
             throw errors_1.emptyContractError;
         }
@@ -33,7 +31,7 @@ class FT {
         if (!jettonMinterCode.equals(thisCode)) {
             return Struct_2.Origin.TON;
         }
-        const jettonMinter = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
+        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)
@@ -48,30 +46,40 @@ class FT {
         }
         return Struct_2.Origin.TAC;
     }
-    static async getTVMAddress(configuration, evmAddress) {
-        Validator_1.Validator.validateEVMAddress(evmAddress);
-        const exists = await configuration.TACParams.tokenUtils['exists(address)'](evmAddress);
+    static async getTVMAddress(configuration, address) {
+        Validator_1.Validator.validateEVMAddress(address);
+        const exists = await configuration.TACParams.tokenUtils['exists(address)'](address);
         if (exists) {
-            const erc721Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(evmAddress, configuration.TACParams.provider);
-            const info = await erc721Token.getInfo();
+            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: evmAddress,
+            evmTokenAddress: address,
             crossChainLayerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
             code: configuration.TONParams.jettonMinterCode,
             walletCode: configuration.TONParams.jettonWalletCode,
         });
         return jettonMaster.address.toString();
     }
-    constructor(tvmTokenAddress, origin, configuration) {
+    constructor(address, origin, configuration) {
         this.type = Struct_1.AssetType.FT;
-        this._tokenAddress = ton_1.Address.parse(tvmTokenAddress);
+        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;
     }
@@ -133,10 +141,9 @@ class FT {
     }
     async generatePayload(params) {
         const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
-        const opType = this.origin === Struct_2.Origin.TAC ? InternalStruct_1.AssetOpType.JETTON_BURN : InternalStruct_1.AssetOpType.JETTON_TRANSFER;
         const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;
-        switch (opType) {
+        switch (this.opType) {
             case InternalStruct_1.AssetOpType.JETTON_BURN:
                 payload = this.getBurnPayload(this._transferAmount, this._configuration.TONParams.crossChainLayerAddress, evmData, crossChainTonAmount, feeData);
                 break;
@@ -146,7 +153,7 @@ class FT {
         }
         return payload;
     }
-    async getOpType() {
+    get opType() {
         return this.origin === 'TAC' ? InternalStruct_1.AssetOpType.JETTON_BURN : InternalStruct_1.AssetOpType.JETTON_TRANSFER;
     }
     async getWallet(userAddress) {

package/dist/assets/NFT.d.ts

@@ -1,30 +1,45 @@
 import { Address, Cell } from '@ton/ton';
 import { IConfiguration } from '../structs/Services';
-import { Asset, AssetType, ContractOpener, FeeParams, NFTItemData, Origin } from '../structs/Struct';
+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;
-    static fromItem(configuration: IConfiguration, tvmItemAddress: string, origin: Origin): Promise<NFT>;
-    static fromCollection(configuration: IConfiguration, tvmAddress: {
-        collection: string;
+    /**
+     * @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;
-    }, origin: Origin): Promise<NFT>;
-    static getItemData(contractOpener: ContractOpener, tvmAddress: string): Promise<NFTItemData>;
-    static getCollectionData(contractOpener: ContractOpener, tvmAddress: string): Promise<{
+    }): 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(contractOpener: ContractOpener, tvmAddress: string, configuration: IConfiguration): Promise<Origin>;
-    static getItemAddress(contractOpener: ContractOpener, tvmCollectionAddress: string, index: bigint): Promise<string>;
-    static getTVMAddress(configuration: IConfiguration, evmAddress: string, tokenId?: bigint): Promise<string>;
-    constructor(tvmNFTAddress: {
-        item: string;
-        collection: string;
+    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;
@@ -35,12 +50,6 @@ export declare class NFT implements Asset {
     get address(): string;
     get rawAmount(): bigint;
     get clone(): NFT;
-    getItemData(): Promise<NFTItemData>;
-    getCollectionData(): Promise<{
-        nextIndex: number;
-        content: Cell;
-        ownerAddress: Address;
-    }>;
     withAmount(): Promise<NFT>;
     addAmount(): Promise<NFT>;
     getEVMAddress(): Promise<string>;

package/dist/assets/NFT.js

@@ -3,6 +3,7 @@ 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");
@@ -10,62 +11,97 @@ const Validator_1 = require("../sdk/Validator");
 const InternalStruct_1 = require("../structs/InternalStruct");
 const Struct_1 = require("../structs/Struct");
 class NFT {
-    static async fromItem(configuration, tvmItemAddress, origin) {
-        Validator_1.Validator.validateTVMAddress(tvmItemAddress);
-        const { collectionAddress, index } = await NFT.getItemData(configuration.TONParams.contractOpener, tvmItemAddress);
-        return new NFT({ item: tvmItemAddress, collection: collectionAddress.toString(), index: BigInt(index) }, origin, configuration);
-    }
-    static async fromCollection(configuration, tvmAddress, origin) {
-        Validator_1.Validator.validateTVMAddress(tvmAddress.collection);
-        const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(tvmAddress.collection)));
-        const itemAddress = await nftCollection.getNFTAddressByIndex(tvmAddress.index);
-        return new NFT({ item: itemAddress.toString(), collection: tvmAddress.collection, index: tvmAddress.index }, origin, configuration);
-    }
-    static async getItemData(contractOpener, tvmAddress) {
-        Validator_1.Validator.validateTVMAddress(tvmAddress);
-        const nftItem = contractOpener.open(wrappers_1.NFTItem.createFromAddress(ton_1.Address.parse(tvmAddress)));
+    /**
+     * @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 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)
+     * @param origin - Origin
+     * @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();
     }
-    static async getCollectionData(contractOpener, tvmAddress) {
-        Validator_1.Validator.validateTVMAddress(tvmAddress);
-        const nftCollection = contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(tvmAddress)));
+    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();
     }
-    static async getOrigin(contractOpener, tvmAddress, configuration) {
-        const { nftItemCode } = configuration.TONParams;
-        const { code: itemCodeBOC } = await contractOpener.getContractState(ton_1.Address.parse(tvmAddress));
-        if (!itemCodeBOC) {
+    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 givenNFTItemCode = ton_1.Cell.fromBoc(itemCodeBOC)[0];
-        if (!nftItemCode.equals(givenNFTItemCode)) {
-            return Struct_1.Origin.TON;
+        const givenNFTCode = ton_1.Cell.fromBoc(givenCodeBOC)[0];
+        if (nftItemCode.equals(givenNFTCode) || nftCollectionCode.equals(givenNFTCode)) {
+            return Struct_1.Origin.TAC;
         }
-        return Struct_1.Origin.TAC;
+        return Struct_1.Origin.TON;
     }
-    static getItemAddress(contractOpener, tvmCollectionAddress, index) {
-        Validator_1.Validator.validateTVMAddress(tvmCollectionAddress);
-        const nftCollection = contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(tvmCollectionAddress)));
+    static getItemAddress(contractOpener, collectionAddress, index) {
+        Validator_1.Validator.validateTVMAddress(collectionAddress);
+        const nftCollection = contractOpener.open(wrappers_1.NFTCollection.createFromAddress(ton_1.Address.parse(collectionAddress)));
         return nftCollection.getNFTAddressByIndex(index).then(toString);
     }
-    static async getTVMAddress(configuration, evmAddress, tokenId) {
-        Validator_1.Validator.validateEVMAddress(evmAddress);
-        let nftCollection;
-        const exists = await configuration.TACParams.tokenUtils['exists(address)'](evmAddress);
+    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(evmAddress, configuration.TACParams.provider);
+            const erc721Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC721FactoryTAC.connect(collectionAddress, configuration.TACParams.provider);
             const info = await erc721Token.getInfo();
-            nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(info.tvmAddress)));
+            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 {
-            nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
+            const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
                 ownerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
                 content: (0, ton_1.beginCell)().endCell(),
                 nftItemCode: configuration.TONParams.nftItemCode,
-                originalAddress: evmAddress,
+                originalAddress: collectionAddress,
             }, configuration.TONParams.nftCollectionCode));
             return tokenId == undefined
                 ? nftCollection.address.toString()
@@ -77,9 +113,9 @@ class NFT {
                 }, configuration.TONParams.nftItemCode).address.toString();
         }
     }
-    constructor(tvmNFTAddress, origin, configuration) {
+    constructor(nftAddress, origin, configuration) {
         this.type = Struct_1.AssetType.NFT;
-        this._addresses = tvmNFTAddress;
+        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)));
@@ -96,12 +132,6 @@ class NFT {
     get clone() {
         return new NFT(this._addresses, this.origin, this._configuration);
     }
-    async getItemData() {
-        return NFT.getItemData(this._configuration.TONParams.contractOpener, this._addresses.item);
-    }
-    async getCollectionData() {
-        return NFT.getCollectionData(this._configuration.TONParams.contractOpener, this._addresses.collection);
-    }
     async withAmount() {
         return this;
     }

package/dist/errors/instances.d.ts

@@ -20,5 +20,5 @@ export declare const noValidGroupFoundError: NoValidGroupFoundError;
 export declare const allEndpointsFailedError: (inner: unknown) => FetchError;
 export declare const allContractOpenerFailedError: (inner: unknown) => FetchError;
 export declare const insufficientBalanceError: (token: string) => InsufficientBalanceError;
-export declare const unknownTokenTypeError: (token: string) => TokenError;
+export declare const unknownTokenTypeError: (token: string, reason?: string) => TokenError;
 export declare const indexRequiredError: (token: string) => TokenError;

package/dist/errors/instances.js

@@ -41,7 +41,7 @@ const allContractOpenerFailedError = (inner) => new errors_1.FetchError('All con
 exports.allContractOpenerFailedError = allContractOpenerFailedError;
 const insufficientBalanceError = (token) => new errors_1.InsufficientBalanceError(`Insufficient balance of ${token}`, 120);
 exports.insufficientBalanceError = insufficientBalanceError;
-const unknownTokenTypeError = (token) => new errors_1.TokenError(`Unknown token type of ${token}`, 121);
+const unknownTokenTypeError = (token, reason) => new errors_1.TokenError(`Unknown token type of ${token}: ${reason}`, 121);
 exports.unknownTokenTypeError = unknownTokenTypeError;
 const indexRequiredError = (token) => new errors_1.TokenError(`Index is required for collection ${token}`, 122);
 exports.indexRequiredError = indexRequiredError;

package/dist/sdk/TransactionManager.js

@@ -194,8 +194,15 @@ class TransactionManager {
         if (assets == undefined) {
             assets = [];
         }
+        const tonAssets = [...assets];
+        if (value > 0n) {
+            tonAssets.push(await (await assets_1.AssetFactory.from(this.config, {
+                address: await this.config.nativeTACAddress(),
+                tokenType: Struct_1.AssetType.FT,
+            })).withAmount({ rawAmount: value }));
+        }
         Validator_1.Validator.validateTVMAddress(tonTarget);
-        const suggestedTONExecutorFee = await this.simulator.getTVMExecutorFeeInfo(assets, Consts_1.TAC_SYMBOL);
+        const suggestedTONExecutorFee = await this.simulator.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
         this.logger.debug(`Suggested TON executor fee: ${(0, Utils_1.formatObjectForLogging)(suggestedTONExecutorFee)}`);
         const crossChainLayerAddress = await this.config.TACParams.crossChainLayer.getAddress();
         for (const asset of assets) {

package/dist/sdk/Validator.js

@@ -35,7 +35,7 @@ class Validator {
         }
     }
     static validateEVMAddress(address) {
-        if (!(0, ethers_1.isAddress)(address)) {
+        if (!address.startsWith('0x') || !(0, ethers_1.isAddress)(address)) {
             throw (0, instances_1.evmAddressError)(address);
         }
     }

package/dist/structs/Struct.d.ts

@@ -354,3 +354,5 @@ export declare enum Origin {
     TON = "TON",
     TAC = "TAC"
 }
+export type TVMAddress = string;
+export type EVMAddress = string;

package/package.json

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