@tonappchain/sdk 0.7.0-rc24-test-8 → 0.7.0-rc24-test-9

package/dist/{src/adapters → adapters}/contractOpener.d.ts

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

package/dist/{src/adapters → adapters}/contractOpener.js

@@ -6,42 +6,9 @@ exports.orbsOpener = orbsOpener;
 exports.orbsOpener4 = orbsOpener4;
 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 artifacts_1 = require("../../artifacts");
-const Utils_1 = require("../sdk/Utils");
 const Struct_1 = require("../structs/Struct");
-async function getHttpEndpointWithRetry(network, maxRetries = 5, delay = 1000) {
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
-            return await (0, ton_access_1.getHttpEndpoint)({ network: tonNetwork });
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt <= maxRetries) {
-                await (0, Utils_1.sleep)(delay);
-            }
-        }
-    }
-    throw lastError || new Error('Failed to get HTTP endpoint after retries');
-}
-async function getHttpV4EndpointWithRetry(network, maxRetries = 5, delay = 1000) {
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
-            return await (0, ton_access_1.getHttpV4Endpoint)({ network: tonNetwork });
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt <= maxRetries) {
-                await (0, Utils_1.sleep)(delay);
-            }
-        }
-    }
-    throw lastError || new Error('Failed to get HTTP V4 endpoint after retries');
-}
 function intToIP(int) {
     const part1 = int & 255;
     const part2 = (int >> 8) & 255;
@@ -50,7 +17,7 @@ function intToIP(int) {
     return part4 + '.' + part3 + '.' + part2 + '.' + part1;
 }
 async function getDefaultLiteServers(network) {
-    const url = network === Struct_1.Network.TESTNET || network === Struct_1.Network.DEV ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
+    const url = network === Struct_1.Network.TESTNET ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
     const resp = await fetch(url);
     const liteClients = await resp.json();
     return liteClients.liteservers;
@@ -100,11 +67,13 @@ function sandboxOpener(blockchain) {
     };
 }
 async function orbsOpener(network) {
-    const endpoint = await getHttpEndpointWithRetry(network);
+    const endpoint = await (0, ton_access_1.getHttpEndpoint)({
+        network,
+    });
     return new ton_1.TonClient({ endpoint });
 }
 async function orbsOpener4(network, timeout = 10000) {
-    const endpoint = await getHttpV4EndpointWithRetry(network);
+    const endpoint = await (0, ton_access_1.getHttpV4Endpoint)({ network });
     const client4 = new ton_1.TonClient4({ endpoint, timeout });
     return {
         open: (contract) => client4.open(contract),

package/dist/{src/adapters → adapters}/retryableContractOpener.d.ts

@@ -1,13 +1,10 @@
 import { SandboxContract } from '@ton/sandbox';
 import { Address, Contract, OpenedContract } from '@ton/ton';
-import { ContractOpener } from '../interfaces';
-import { ContractState, Network } from '../structs/Struct';
+import { mainnet, testnet } from '@tonappchain/artifacts';
+import { ContractOpener, ContractState } from '../structs/Struct';
 export interface OpenerConfig {
-    /** Underlying opener implementation to use for this slot. */
     opener: ContractOpener;
-    /** Number of retry attempts before falling back to the next opener. */
     retries: number;
-    /** Delay in milliseconds between retries for this opener. */
     retryDelay: number;
 }
 export declare class RetryableContractOpener implements ContractOpener {
@@ -21,4 +18,4 @@ export declare class RetryableContractOpener implements ContractOpener {
     private createRetryableContract;
     private callMethodAcrossOpeners;
 }
-export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;
+export declare function createDefaultRetryableOpener(artifacts: typeof testnet | typeof mainnet, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/{src/adapters → adapters}/retryableContractOpener.js

@@ -3,6 +3,7 @@ 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");
@@ -85,16 +86,16 @@ class RetryableContractOpener {
     }
 }
 exports.RetryableContractOpener = RetryableContractOpener;
-async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = 5, retryDelay = 1000) {
-    const openers = [];
+async function createDefaultRetryableOpener(artifacts, maxRetries = 3, retryDelay = 1000) {
     const tonClient = new ton_1.TonClient({
-        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
+        endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString(),
     });
-    openers.push({ opener: tonClient, retries: maxRetries, retryDelay });
-    if (networkType !== Struct_1.Network.DEV) {
-        const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
-        const opener = await (0, contractOpener_1.orbsOpener)(networkType);
-        openers.push({ opener: opener4, retries: maxRetries, retryDelay }, { opener: opener, retries: maxRetries, retryDelay });
-    }
-    return new RetryableContractOpener(openers);
+    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/{src/assets → assets}/AssetCache.d.ts

@@ -1,4 +1,4 @@
-import { Asset } from '../interfaces';
+import { Asset } from '../structs/Struct';
 export declare class AssetCache {
     private static readonly cache;
     /**

package/dist/{src/assets → assets}/AssetFactory.d.ts

@@ -1,5 +1,5 @@
-import { Asset, IConfiguration } from '../interfaces';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
+import { IConfiguration } from '../structs/Services';
+import { Asset, AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
 export declare class AssetFactory {
     static from(configuration: IConfiguration, token: AssetFromFTArg | AssetFromNFTCollectionArg | AssetFromNFTItemArg): Promise<Asset>;
     static createFTAsset(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<Asset>;

package/dist/{src/assets → assets}/AssetFactory.js

@@ -16,7 +16,7 @@ class AssetFactory {
         }
         const cachedAsset = AssetCache_1.AssetCache.get(token);
         if (cachedAsset) {
-            return cachedAsset.clone.withRawAmount(0n);
+            return cachedAsset.clone.withAmount({ rawAmount: 0n });
         }
         const asset = token.tokenType === Struct_1.AssetType.FT
             ? await this.createFTAsset(configuration, token.address)

package/dist/{src/assets → assets}/FT.d.ts

@@ -1,35 +1,37 @@
 import { SandboxContract } from '@ton/sandbox';
 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 { Origin } from '../structs/Struct';
+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 _tvmAddress;
     readonly type: AssetType;
     readonly origin: Origin;
     private _configuration;
     private _jettonMinter;
-    private _decimals;
+    private _decimals?;
     private _transferAmount;
     private _evmAddress?;
     get address(): string;
-    static getJettonData(configuration: IConfiguration, address: TVMAddress): Promise<JettonMinterData>;
-    getJettonData(): Promise<JettonMinterData>;
+    static getJettonData(contractOpener: ContractOpener, address: TVMAddress): Promise<import("../wrappers/JettonMaster").JettonMasterData>;
     static getOrigin(configuration: IConfiguration, address: TVMAddress): Promise<Origin>;
-    static getOriginAndData(configuration: IConfiguration, address: TVMAddress): Promise<FTOriginAndData>;
     static getTVMAddress(configuration: IConfiguration, address: EVMAddress): Promise<string>;
-    static getEVMAddress(configuration: IConfiguration, address: TVMAddress): Promise<string>;
     private constructor();
-    private static getTACDecimals;
     static fromAddress(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<FT>;
     get rawAmount(): bigint;
     get clone(): FT;
-    withAmount(amount: number): FT;
-    withRawAmount(rawAmount: bigint): FT;
-    addAmount(amount: number): FT;
-    addRawAmount(rawAmount: bigint): 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>;
@@ -46,7 +48,7 @@ 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>;
+    checkCanBeTransferedBy(userAddress: string): Promise<void>;
     getBalanceOf(userAddress: string): Promise<bigint>;
     private getTransferPayload;
     private getBurnPayload;

package/dist/{src/assets → assets}/FT.js

@@ -10,36 +10,29 @@ 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 ContentUtils_1 = require("../wrappers/ContentUtils");
+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(configuration, address) {
+    static async getJettonData(contractOpener, address) {
         Validator_1.Validator.validateTVMAddress(address);
-        const jetton = configuration.TONParams.contractOpener.open(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(address)));
-        return jetton.getJettonData();
-    }
-    async getJettonData() {
-        return FT.getJettonData(this._configuration, this._tvmAddress.toString());
+        const jetton = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
+        return await jetton.getJettonData();
     }
     static async getOrigin(configuration, address) {
-        const result = await this.getOriginAndData(configuration, address);
-        return result.origin;
-    }
-    static async getOriginAndData(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];
-        const jettonMinter = configuration.TONParams.contractOpener.open(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(address)));
         if (!jettonMinterCode.equals(thisCode)) {
-            const jettonData = await jettonMinter.getJettonData();
-            return { origin: Struct_2.Origin.TON, jettonMinter, jettonData };
+            return Struct_2.Origin.TON;
         }
-        const evmAddress = await jettonMinter.getEVMTokenAddress();
+        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))
@@ -49,93 +42,47 @@ class FT {
             .storeStringTail(evmAddress)
             .endCell());
         if (!expectedMinterAddress.equals(ton_1.Address.parse(address))) {
-            const jettonData = await jettonMinter.getJettonData();
-            return { origin: Struct_2.Origin.TON, jettonMinter, jettonData };
+            return Struct_2.Origin.TON;
         }
-        return { origin: Struct_2.Origin.TAC, jettonMinter, evmAddress };
+        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 cclErc20Abi = configuration.artifacts.tac.compilationArtifacts.ICrossChainLayerERC20.abi;
-            const erc20Token = new ethers_1.ethers.Contract(address, cclErc20Abi, configuration.TACParams.provider);
+            const erc20Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(address, configuration.TACParams.provider);
             const info = await erc20Token.getInfo();
             return info.tvmAddress;
         }
-        const jettonMaster = configuration.artifacts.ton.wrappers.JettonMinter.createFromConfig({
-            totalSupply: 0n,
-            adminAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
-            jettonWalletCode: configuration.TONParams.jettonWalletCode,
+        // If token is TAC native
+        const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
             evmTokenAddress: address,
-            content: (0, ton_1.beginCell)().endCell(),
-        }, configuration.TONParams.jettonMinterCode);
+            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(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(tokenAddressString)));
-            return givenMinter.getEVMTokenAddress();
-        }
-    }
-    constructor(address, origin, configuration, decimals) {
+    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(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(this._tvmAddress));
+        this._jettonMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(this._tvmAddress));
         this.origin = origin;
         this._transferAmount = 0n;
-        this._decimals = decimals;
-    }
-    static async getTACDecimals(configuration, evmAddress) {
-        const nativeTACAddress = await configuration.nativeTACAddress();
-        if (evmAddress === nativeTACAddress) {
-            return Consts_1.TAC_DECIMALS; // Native TAC always has 18 decimals
-        }
-        // For ERC20 contracts, get decimals from contract
-        const erc20TokenAbi = configuration.artifacts.tac.compilationArtifacts.IERC20WithDecimals.abi;
-        const erc20Token = new ethers_1.ethers.Contract(evmAddress, erc20TokenAbi, configuration.TACParams.provider);
-        return Number(await erc20Token.decimals());
     }
     static async fromAddress(configuration, address) {
         const tvmAddress = (0, ethers_1.isAddress)(address) ? await this.getTVMAddress(configuration, address) : address;
-        const { origin, jettonMinter, evmAddress: cachedEvmAddress, jettonData, } = await this.getOriginAndData(configuration, tvmAddress).catch((e) => {
+        const origin = await FT.getOrigin(configuration, tvmAddress).catch((e) => {
             if (e instanceof errors_1.ContractError) {
-                const jettonMinter = configuration.TONParams.contractOpener.open(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(tvmAddress)));
-                return { origin: Struct_2.Origin.TAC, jettonMinter, evmAddress: undefined, jettonData: undefined };
+                return Struct_2.Origin.TAC;
             }
             throw e;
         });
-        let decimals;
-        let finalEvmAddress;
-        if (origin === Struct_2.Origin.TON) {
-            if (!jettonData) {
-                throw errors_1.missingJettonDataError;
-            }
-            const metadata = await (0, ContentUtils_1.readJettonMetadata)(jettonData.content);
-            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 token = new FT(tvmAddress, origin, configuration, decimals);
-        if (finalEvmAddress || (0, ethers_1.isAddress)(address)) {
-            token._evmAddress = finalEvmAddress || address;
+        const token = new FT(tvmAddress, origin, configuration);
+        if ((0, ethers_1.isAddress)(address)) {
+            token._evmAddress = address;
         }
         return token;
     }
@@ -143,38 +90,44 @@ class FT {
         return this._transferAmount;
     }
     get clone() {
-        const ft = new FT(this._tvmAddress.toString(), this.origin, this._configuration, this._decimals);
+        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;
     }
-    withAmount(amount) {
+    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 = (0, Utils_1.calculateRawAmount)(amount, this._decimals);
+            newToken._transferAmount =
+                'rawAmount' in amount ? amount.rawAmount : (0, Utils_1.calculateRawAmount)(amount.amount, await this.getDecimals());
             return newToken;
         }
-        this._transferAmount = (0, Utils_1.calculateRawAmount)(amount, this._decimals);
-        return this;
-    }
-    withRawAmount(rawAmount) {
-        if (this._transferAmount > 0n) {
-            const newToken = this.clone;
-            newToken._transferAmount = rawAmount;
-            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);
         }
-        this._transferAmount = rawAmount;
-        return this;
-    }
-    addAmount(amount) {
-        this._transferAmount = this._transferAmount + (0, Utils_1.calculateRawAmount)(amount, this._decimals);
         return this;
     }
-    addRawAmount(rawAmount) {
-        this._transferAmount = this._transferAmount + rawAmount;
+    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() {
@@ -186,8 +139,8 @@ class FT {
             this._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();
+            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');
@@ -216,10 +169,10 @@ class FT {
     }
     async getWallet(userAddress) {
         const walletAddress = await this.getUserWalletAddress(userAddress);
-        return this._configuration.TONParams.contractOpener.open(this._configuration.artifacts.ton.wrappers.JettonWallet.createFromAddress(ton_1.Address.parse(walletAddress)));
+        return this._configuration.TONParams.contractOpener.open(JettonWallet_1.JettonWallet.createFromAddress(ton_1.Address.parse(walletAddress)));
     }
     async getUserWalletAddress(userAddress) {
-        return (await this._jettonMinter.getWalletAddress(ton_1.Address.parse(userAddress))).toString({ bounceable: true });
+        return this._jettonMinter.getWalletAddress(userAddress);
     }
     async getUserBalance(userAddress) {
         const wallet = await this.getWallet(userAddress);
@@ -246,7 +199,7 @@ class FT {
             throw (0, errors_1.insufficientBalanceError)(this._tvmAddress.toString());
         }
     }
-    async checkCanBeTransferredBy(userAddress) {
+    async checkCanBeTransferedBy(userAddress) {
         await this.checkBalance(userAddress);
     }
     async getBalanceOf(userAddress) {
@@ -254,11 +207,11 @@ class FT {
     }
     getTransferPayload(rawAmount, notificationReceiverAddress, responseAddress, evmData, crossChainTonAmount, forwardFeeAmount, feeData) {
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        return this._configuration.artifacts.ton.wrappers.JettonWallet.transferMessage(rawAmount, notificationReceiverAddress, responseAddress, Consts_1.JETTON_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount, crossChainTonAmount, feeData, evmData, queryId);
+        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 this._configuration.artifacts.ton.wrappers.JettonWallet.burnMessage(rawAmount, notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
+        return JettonWallet_1.JettonWallet.burnMessage(rawAmount, notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
     }
 }
 exports.FT = FT;

package/dist/{src/assets → assets}/NFT.d.ts

@@ -1,9 +1,8 @@
-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 { 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 readonly _addresses;
+    private _addresses;
     readonly origin: Origin;
     readonly type: AssetType;
     private _nftCollection;
@@ -12,6 +11,7 @@ export declare class NFT implements Asset {
      * @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>;
@@ -19,18 +19,21 @@ export declare class NFT implements Asset {
      * @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(configuration: IConfiguration, itemAddress: TVMAddress): Promise<NFTItemData>;
-    getItemData(): Promise<NFTItemData>;
-    static getCollectionData(configuration: IConfiguration, collectionAddress: TVMAddress): Promise<NFTCollectionData>;
-    getCollectionData(): Promise<NFTCollectionData>;
+    static getItemData(contractOpener: ContractOpener, itemAddress: TVMAddress): Promise<NFTItemData>;
+    static getCollectionData(contractOpener: ContractOpener, collectionAddress: TVMAddress): Promise<{
+        nextIndex: number;
+        content: Cell;
+        adminAddress: Address;
+    }>;
     static getOrigin(configuration: IConfiguration, itemOrCollection: TVMAddress): Promise<Origin>;
-    static getItemAddress(configuration: IConfiguration, collectionAddress: TVMAddress, index: bigint): Promise<string>;
+    static getItemAddress(contractOpener: ContractOpener, collectionAddress: TVMAddress, index: bigint): Promise<string>;
     static getTVMAddress(configuration: IConfiguration, collectionAddress: EVMAddress, tokenId?: bigint): Promise<string>;
     constructor(nftAddress: {
         item: TVMAddress;
@@ -47,10 +50,8 @@ export declare class NFT implements Asset {
     get address(): string;
     get rawAmount(): bigint;
     get clone(): NFT;
-    withAmount(_amount?: number): NFT;
-    withRawAmount(_rawAmount?: bigint): NFT;
-    addAmount(_amount?: number): NFT;
-    addRawAmount(_rawAmount?: bigint): NFT;
+    withAmount(): Promise<NFT>;
+    addAmount(): Promise<NFT>;
     getEVMAddress(): Promise<string>;
     getTVMAddress(): Promise<string>;
     generatePayload(params: {
@@ -61,7 +62,7 @@ export declare class NFT implements Asset {
         feeParams?: FeeParams;
     }): Promise<Cell>;
     isOwnedBy(userAddress: string): Promise<boolean>;
-    checkCanBeTransferredBy(userAddress: string): Promise<void>;
+    checkCanBeTransferedBy(userAddress: string): Promise<void>;
     getBalanceOf(userAddress: string): Promise<bigint>;
     private getBurnPayload;
     private getTransferPayload;