@tonappchain/sdk 0.7.0-rc8 → 0.7.0

package/dist/src/agnosticSdk/ReplacementHelper.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplacementHelper = void 0;
+const ethers_1 = require("ethers");
+class ReplacementHelper {
+    /**
+     * Helper to create dynamic amount replacement for a specific parameter
+     * @param paramIndex - The index of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The amount replacement
+     */
+    createAmountReplacement(paramIndex, token, balanceAddress) {
+        // Calculate position in calldata (4 bytes selector + 32 bytes per param)
+        const position = 4 + paramIndex * 32;
+        return {
+            position,
+            len: 32, // uint256 is 32 bytes
+            token,
+            balanceAddress,
+        };
+    }
+    /**
+     * Advanced replacement calculator - calculates position and length for any parameter type
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The replacement data
+     */
+    calculateReplacementData(contractAddress, functionName, parameterName, token, balanceAddress, contractInterfaces) {
+        const contractInterface = contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}. Please add it first using addContractInterface().`);
+        }
+        let functionFragment;
+        try {
+            functionFragment = contractInterface.getFunction(functionName);
+        }
+        catch {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        if (!functionFragment) {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        // Find the parameter by name
+        const paramIndex = functionFragment.inputs.findIndex((input) => input.name === parameterName);
+        if (paramIndex === -1) {
+            const availableParams = functionFragment.inputs
+                .map((input) => `${input.name} (${input.type})`)
+                .join(', ');
+            throw new Error(`Parameter '${parameterName}' not found in function '${functionName}'. Available parameters: ${availableParams}`);
+        }
+        // Calculate position and length based on parameter type
+        const { position, len } = this._calculateParamPositionAndLength(functionFragment.inputs, paramIndex);
+        return {
+            position,
+            len,
+            token,
+            balanceAddress,
+        };
+    }
+    /**
+     * Get replacement helper - shows available functions and parameters for a contract
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @returns The replacement helper
+     */
+    getReplacementHelper(contractAddress, contractInterfaces) {
+        const contractInterface = contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}. Please add it first using addContractInterface().`);
+        }
+        const functions = contractInterface.fragments
+            .filter((fragment) => fragment.type === 'function')
+            .map((fragment) => {
+            const func = fragment;
+            return {
+                name: func.name,
+                signature: func.format('full'),
+                parameters: func.inputs.map((input, index) => {
+                    const canReplace = this._canParameterBeReplaced(input.type);
+                    return {
+                        name: input.name || `param${index}`,
+                        type: input.type,
+                        index,
+                        canReplace: canReplace.canReplace,
+                        reason: canReplace.reason,
+                    };
+                }),
+            };
+        });
+        return {
+            contractAddress,
+            functions,
+        };
+    }
+    /**
+     * Interactive replacement builder - helps build replacement step by step
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @param options - The options of the interactive replacement builder
+     * @returns The interactive replacement builder
+     */
+    buildReplacementInteractive(contractAddress, functionName, parameterName, token, balanceAddress, contractInterfaces, options = {}) {
+        const { validate = true } = options;
+        // Get the replacement data
+        const replacement = this.calculateReplacementData(contractAddress, functionName, parameterName, token, balanceAddress, contractInterfaces);
+        // Get function info for calculation details
+        const contractInterface = contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}`);
+        }
+        const functionFragment = contractInterface.getFunction(functionName);
+        if (!functionFragment) {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        const paramIndex = functionFragment.inputs.findIndex((input) => input.name === parameterName);
+        const param = functionFragment.inputs[paramIndex];
+        const calculation = {
+            functionSignature: functionFragment.format('full'),
+            parameterInfo: {
+                name: parameterName,
+                type: param.type,
+                index: paramIndex,
+                position: replacement.position,
+                length: replacement.len,
+            },
+            positionCalculation: `Position = 4 bytes (selector) + ${paramIndex} * 32 bytes = ${replacement.position} bytes`,
+        };
+        // Validation
+        const validation = {
+            isValid: true,
+            warnings: [],
+            suggestions: [],
+        };
+        if (validate) {
+            // Check if parameter type is suitable for replacement
+            const typeCheck = this._canParameterBeReplaced(param.type);
+            if (!typeCheck.canReplace) {
+                validation.isValid = false;
+                validation.warnings.push(`Parameter type '${param.type}' ${typeCheck.reason}`);
+            }
+            // Check if it's a reasonable parameter to replace
+            if (param.name.toLowerCase().includes('amount') || param.name.toLowerCase().includes('value')) {
+                validation.suggestions.push(`✅ Parameter '${param.name}' looks suitable for dynamic replacement`);
+            }
+            else {
+                validation.warnings.push(`⚠️ Parameter '${param.name}' might not be intended for amount replacement`);
+            }
+            // Check token address
+            if (!ethers_1.ethers.isAddress(token)) {
+                validation.isValid = false;
+                validation.warnings.push(`Invalid token address: ${token}`);
+            }
+            if (!ethers_1.ethers.isAddress(balanceAddress)) {
+                validation.isValid = false;
+                validation.warnings.push(`Invalid balance address: ${balanceAddress}`);
+            }
+        }
+        return {
+            replacement,
+            calculation,
+            validation,
+        };
+    }
+    /**
+     * Private helper to calculate position and length for complex parameter types
+     * @param inputs - The inputs of the function
+     * @param targetIndex - The index of the parameter to calculate the position and length for
+     * @returns The position and length of the parameter
+     */
+    _calculateParamPositionAndLength(inputs, targetIndex) {
+        // For now, we support simple types. Complex types (arrays, structs) would need more sophisticated calculation
+        // This is a simplified version that works for basic types like uint256, address, etc.
+        let position = 4; // Start after function selector
+        for (let i = 0; i < targetIndex; i++) {
+            const paramType = inputs[i].type;
+            position += this._getTypeSize(paramType);
+        }
+        const targetType = inputs[targetIndex].type;
+        const len = this._getTypeSize(targetType);
+        return { position, len };
+    }
+    /**
+     * Get the size in bytes for a parameter type
+     * @param type - The type of the parameter
+     * @returns The size in bytes of the parameter
+     */
+    _getTypeSize(type) {
+        // Basic types are all 32 bytes in calldata (due to ABI encoding)
+        if (type.startsWith('uint') ||
+            type.startsWith('int') ||
+            type === 'address' ||
+            type === 'bool' ||
+            type.startsWith('bytes32')) {
+            return 32;
+        }
+        // Dynamic types (bytes, string) are also 32 bytes for the offset
+        if (type === 'bytes' || type === 'string') {
+            return 32;
+        }
+        // Arrays are 32 bytes for the offset
+        if (type.includes('[]')) {
+            return 32;
+        }
+        // Default to 32 bytes for unknown types
+        return 32;
+    }
+    /**
+     * Check if a parameter type can be replaced with a balance
+     * @param type - The type of the parameter
+     * @returns The can replace and reason of the parameter
+     */
+    _canParameterBeReplaced(type) {
+        if (type.startsWith('uint') && !type.includes('[]')) {
+            return { canReplace: true };
+        }
+        if (type.startsWith('int') && !type.includes('[]')) {
+            return { canReplace: true, reason: 'but be careful with signed integers' };
+        }
+        return {
+            canReplace: false,
+            reason: `is not suitable for balance replacement. Only uint/int types are supported.`,
+        };
+    }
+}
+exports.ReplacementHelper = ReplacementHelper;

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

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

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

@@ -1,5 +1,5 @@
-import { IConfiguration } from '../structs/Services';
-import { Asset, AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, EVMAddress, NFTAddressType, TVMAddress } from '../structs/Struct';
+import { Asset, IConfiguration } from '../interfaces';
+import { 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/{assets → src/assets}/AssetFactory.js

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

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

@@ -1,37 +1,35 @@
 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 { 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';
+import { AssetType, EVMAddress, FeeParams, FTOriginAndData, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { Origin } from '../structs/Struct';
 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(contractOpener: ContractOpener, address: TVMAddress): Promise<import("../wrappers/JettonMaster").JettonMasterData>;
+    static getJettonData(configuration: IConfiguration, address: TVMAddress): Promise<JettonMinterData>;
+    getJettonData(): Promise<JettonMinterData>;
     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: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<FT>;
-    addAmount(amount: {
-        rawAmount: bigint;
-    } | {
-        amount: number;
-    }): Promise<FT>;
+    withAmount(amount: number): FT;
+    withRawAmount(rawAmount: bigint): FT;
+    addAmount(amount: number): FT;
+    addRawAmount(rawAmount: bigint): FT;
     getDecimals(): Promise<number>;
     getEVMAddress(): Promise<string>;
     getTVMAddress(): Promise<string>;
@@ -48,7 +46,7 @@ export declare class FT implements Asset {
     getUserBalance(userAddress: string): Promise<bigint>;
     getUserBalanceExtended(userAddress: string): Promise<UserWalletBalanceExtended>;
     checkBalance(userAddress: string): Promise<void>;
-    checkCanBeTransferedBy(userAddress: string): Promise<void>;
+    checkCanBeTransferredBy(userAddress: string): Promise<void>;
     getBalanceOf(userAddress: string): Promise<bigint>;
     private getTransferPayload;
     private getBurnPayload;

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

@@ -10,29 +10,36 @@ 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");
+const ContentUtils_1 = require("../wrappers/ContentUtils");
 class FT {
     get address() {
         return this._tvmAddress.toString({ bounceable: true });
     }
-    static async getJettonData(contractOpener, address) {
+    static async getJettonData(configuration, address) {
         Validator_1.Validator.validateTVMAddress(address);
-        const jetton = contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
-        return await jetton.getJettonData();
+        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());
     }
     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)) {
-            return Struct_2.Origin.TON;
+            const jettonData = await jettonMinter.getJettonData();
+            return { origin: Struct_2.Origin.TON, jettonMinter, jettonData };
         }
-        const jettonMinter = configuration.TONParams.contractOpener.open(JettonMaster_1.JettonMaster.createFromAddress(ton_1.Address.parse(address)));
-        const evmAddress = await jettonMinter.getEVMAddress();
+        const evmAddress = await jettonMinter.getEVMTokenAddress();
         const expectedMinterAddress = await (0, Utils_1.calculateContractAddress)(jettonMinterCode, (0, ton_1.beginCell)()
             .storeCoins(0)
             .storeAddress(ton_1.Address.parse(crossChainLayerAddress))
@@ -42,47 +49,93 @@ class FT {
             .storeStringTail(evmAddress)
             .endCell());
         if (!expectedMinterAddress.equals(ton_1.Address.parse(address))) {
-            return Struct_2.Origin.TON;
+            const jettonData = await jettonMinter.getJettonData();
+            return { origin: Struct_2.Origin.TON, jettonMinter, jettonData };
         }
-        return Struct_2.Origin.TAC;
+        return { origin: Struct_2.Origin.TAC, jettonMinter, evmAddress };
     }
     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 cclErc20Abi = configuration.artifacts.tac.compilationArtifacts.ICrossChainLayerERC20.abi;
+            const erc20Token = new ethers_1.ethers.Contract(address, cclErc20Abi, configuration.TACParams.provider);
             const info = await erc20Token.getInfo();
             return info.tvmAddress;
         }
-        // If token is TAC native
-        const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
+        const jettonMaster = configuration.artifacts.ton.wrappers.JettonMinter.createFromConfig({
+            totalSupply: 0n,
+            adminAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
+            jettonWalletCode: configuration.TONParams.jettonWalletCode,
             evmTokenAddress: address,
-            crossChainLayerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
-            code: configuration.TONParams.jettonMinterCode,
-            walletCode: configuration.TONParams.jettonWalletCode,
-        });
+            content: (0, ton_1.beginCell)().endCell(),
+        }, configuration.TONParams.jettonMinterCode);
         return jettonMaster.address.toString();
     }
-    constructor(address, origin, configuration) {
+    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) {
         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._jettonMinter = this._configuration.TONParams.contractOpener.open(configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(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 = await FT.getOrigin(configuration, tvmAddress).catch((e) => {
+        const { origin, jettonMinter, evmAddress: cachedEvmAddress, jettonData, } = await this.getOriginAndData(configuration, tvmAddress).catch((e) => {
             if (e instanceof errors_1.ContractError) {
-                return Struct_2.Origin.TAC;
+                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 };
             }
             throw e;
         });
-        const token = new FT(tvmAddress, origin, configuration);
-        if ((0, ethers_1.isAddress)(address)) {
-            token._evmAddress = address;
+        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;
         }
         return token;
     }
@@ -90,44 +143,38 @@ class FT {
         return this._transferAmount;
     }
     get clone() {
-        const ft = new FT(this._tvmAddress.toString(), this.origin, this._configuration);
+        const ft = new FT(this._tvmAddress.toString(), this.origin, this._configuration, this._decimals);
         ft._transferAmount = this._transferAmount;
         ft._evmAddress = this._evmAddress;
-        ft._decimals = this._decimals;
         return ft;
     }
-    async withAmount(amount) {
+    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());
+            newToken._transferAmount = (0, Utils_1.calculateRawAmount)(amount, this._decimals);
             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 = (0, Utils_1.calculateRawAmount)(amount, this._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);
+    withRawAmount(rawAmount) {
+        if (this._transferAmount > 0n) {
+            const newToken = this.clone;
+            newToken._transferAmount = rawAmount;
+            return newToken;
         }
+        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;
         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() {
@@ -139,8 +186,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(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddressString)));
-            this._evmAddress = await givenMinter.getEVMAddress();
+            const givenMinter = this._configuration.TONParams.contractOpener.open(this._configuration.artifacts.ton.wrappers.JettonMinter.createFromAddress(ton_1.Address.parse(tokenAddressString)));
+            this._evmAddress = await givenMinter.getEVMTokenAddress();
         }
         else {
             throw (0, errors_1.unknownTokenTypeError)(tokenAddressString, 'Token origin is neither TON nor TAC');
@@ -169,10 +216,10 @@ class FT {
     }
     async getWallet(userAddress) {
         const walletAddress = await this.getUserWalletAddress(userAddress);
-        return this._configuration.TONParams.contractOpener.open(JettonWallet_1.JettonWallet.createFromAddress(ton_1.Address.parse(walletAddress)));
+        return this._configuration.TONParams.contractOpener.open(this._configuration.artifacts.ton.wrappers.JettonWallet.createFromAddress(ton_1.Address.parse(walletAddress)));
     }
     async getUserWalletAddress(userAddress) {
-        return this._jettonMinter.getWalletAddress(userAddress);
+        return (await this._jettonMinter.getWalletAddress(ton_1.Address.parse(userAddress))).toString({ bounceable: true });
     }
     async getUserBalance(userAddress) {
         const wallet = await this.getWallet(userAddress);
@@ -199,7 +246,7 @@ class FT {
             throw (0, errors_1.insufficientBalanceError)(this._tvmAddress.toString());
         }
     }
-    async checkCanBeTransferedBy(userAddress) {
+    async checkCanBeTransferredBy(userAddress) {
         await this.checkBalance(userAddress);
     }
     async getBalanceOf(userAddress) {
@@ -207,11 +254,11 @@ class FT {
     }
     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);
+        return this._configuration.artifacts.ton.wrappers.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);
+        return this._configuration.artifacts.ton.wrappers.JettonWallet.burnMessage(rawAmount, notificationReceiverAddress, crossChainTonAmount, feeData, evmData, queryId);
     }
 }
 exports.FT = FT;

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

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