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

package/dist/assets/AssetFactory.d.ts

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

package/dist/assets/AssetFactory.js

@@ -8,9 +8,10 @@ const FT_1 = require("./FT");
 const NFT_1 = require("./NFT");
 const TON_1 = require("./TON");
 class AssetFactory {
-    /// PUBLIC
     static async from(configuration, token) {
         if (token.address === '' || token.address === configuration.nativeTONAddress) {
+            if (token.tokenType !== Struct_1.AssetType.FT)
+                throw (0, errors_1.unknownTokenTypeError)(token.address, 'detected TON, but token type is not FT');
             return TON_1.TON.create(configuration);
         }
         const cachedAsset = AssetCache_1.AssetCache.get(token);
@@ -23,12 +24,12 @@ class AssetFactory {
         AssetCache_1.AssetCache.set(token, asset);
         return asset;
     }
-    /// PRIVATE
-    /// CREATE FT ASSET
     static async createFTAsset(configuration, address) {
+        if (address === configuration.nativeTONAddress || address === '') {
+            return TON_1.TON.create(configuration);
+        }
         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);

package/dist/assets/FT.d.ts

@@ -6,7 +6,7 @@ import { AssetType, ContractOpener, EVMAddress, FeeParams, TVMAddress, UserWalle
 import { Asset, Origin } from '../structs/Struct';
 import { JettonWallet } from '../wrappers/JettonWallet';
 export declare class FT implements Asset {
-    private _tokenAddress;
+    private _tvmAddress;
     readonly type: AssetType;
     readonly origin: Origin;
     private _configuration;
@@ -18,6 +18,7 @@ export declare class FT implements Asset {
     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>;
+    static getEVMAddress(configuration: IConfiguration, address: TVMAddress): Promise<string>;
     private constructor();
     static fromAddress(configuration: IConfiguration, address: TVMAddress | EVMAddress): Promise<FT>;
     get rawAmount(): bigint;

package/dist/assets/FT.js

@@ -14,7 +14,7 @@ const JettonMaster_1 = require("../wrappers/JettonMaster");
 const JettonWallet_1 = require("../wrappers/JettonWallet");
 class FT {
     get address() {
-        return this._tokenAddress.toString();
+        return this._tvmAddress.toString({ bounceable: true });
     }
     static async getJettonData(contractOpener, address) {
         Validator_1.Validator.validateTVMAddress(address);
@@ -48,12 +48,14 @@ class FT {
     }
     static async getTVMAddress(configuration, address) {
         Validator_1.Validator.validateEVMAddress(address);
-        const exists = await configuration.TACParams.tokenUtils['exists(address)'](address);
-        if (exists) {
+        // If token is TON native
+        const fromTVM = await configuration.TACParams.tokenUtils['exists(address)'](address);
+        if (fromTVM) {
             const erc20Token = configuration.artifacts.tac.wrappers.CrossChainLayerERC20FactoryTAC.connect(address, configuration.TACParams.provider);
             const info = await erc20Token.getInfo();
             return info.tvmAddress;
         }
+        // If token is TAC native
         const jettonMaster = JettonMaster_1.JettonMaster.createFromConfig({
             evmTokenAddress: address,
             crossChainLayerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
@@ -62,11 +64,22 @@ class FT {
         });
         return jettonMaster.address.toString();
     }
+    static async getEVMAddress(configuration, address) {
+        const tokenAddressString = ton_1.Address.parse(address).toString({ bounceable: true });
+        const origin = await FT.getOrigin(configuration, address);
+        if (origin === Struct_2.Origin.TON) {
+            return configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
+        }
+        else {
+            const givenMinter = configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddressString)));
+            return givenMinter.getEVMAddress();
+        }
+    }
     constructor(address, origin, configuration) {
         this.type = Struct_1.AssetType.FT;
-        this._tokenAddress = ton_1.Address.parse(address);
+        this._tvmAddress = ton_1.Address.parse(address);
         this._configuration = configuration;
-        this._jettonMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(this._tokenAddress));
+        this._jettonMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(this._tvmAddress));
         this.origin = origin;
         this._transferAmount = 0n;
     }
@@ -78,13 +91,17 @@ class FT {
             }
             throw e;
         });
-        return new FT(tvmAddress, origin, configuration);
+        const token = new FT(tvmAddress, origin, configuration);
+        if ((0, ethers_1.isAddress)(address)) {
+            token._evmAddress = address;
+        }
+        return token;
     }
     get rawAmount() {
         return this._transferAmount;
     }
     get clone() {
-        const ft = new FT(this._tokenAddress.toString(), this.origin, this._configuration);
+        const ft = new FT(this._tvmAddress.toString(), this.origin, this._configuration);
         ft._transferAmount = this._transferAmount;
         ft._evmAddress = this._evmAddress;
         ft._decimals = this._decimals;
@@ -128,16 +145,21 @@ class FT {
         if (this._evmAddress) {
             return this._evmAddress;
         }
-        if (this.origin === Struct_2.Origin.TAC) {
-            this._evmAddress = await this._jettonMinter.getEVMAddress();
+        const tokenAddressString = this._tvmAddress.toString({ bounceable: true });
+        if (this.origin === Struct_2.Origin.TON) {
+            this._evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(tokenAddressString);
+        }
+        else if (this.origin === Struct_2.Origin.TAC) {
+            const givenMinter = this._configuration.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster(ton_1.Address.parse(tokenAddressString)));
+            this._evmAddress = await givenMinter.getEVMAddress();
         }
         else {
-            this._evmAddress = await this._configuration.TACParams.tokenUtils.computeAddress(this._tokenAddress.toString());
+            throw (0, errors_1.unknownTokenTypeError)(tokenAddressString, 'Token origin is neither TON nor TAC');
         }
         return this._evmAddress;
     }
     async getTVMAddress() {
-        return this._tokenAddress.toString();
+        return this._tvmAddress.toString({ bounceable: true });
     }
     async generatePayload(params) {
         const { excessReceiver, evmData, crossChainTonAmount = 0n, forwardFeeTonAmount = 0n, feeParams } = params;
@@ -154,7 +176,7 @@ class FT {
         return payload;
     }
     get opType() {
-        return this.origin === 'TAC' ? InternalStruct_1.AssetOpType.JETTON_BURN : InternalStruct_1.AssetOpType.JETTON_TRANSFER;
+        return this.origin === Struct_2.Origin.TAC ? InternalStruct_1.AssetOpType.JETTON_BURN : InternalStruct_1.AssetOpType.JETTON_TRANSFER;
     }
     async getWallet(userAddress) {
         const walletAddress = await this.getUserWalletAddress(userAddress);
@@ -168,7 +190,7 @@ class FT {
         return BigInt(await wallet.getJettonBalance());
     }
     async getUserBalanceExtended(userAddress) {
-        const masterState = await this._configuration.TONParams.contractOpener.getContractState(this._tokenAddress);
+        const masterState = await this._configuration.TONParams.contractOpener.getContractState(this._tvmAddress);
         if (masterState.state !== 'active') {
             return { exists: false };
         }
@@ -185,7 +207,7 @@ class FT {
     async checkBalance(userAddress) {
         const balance = await this.getUserBalance(userAddress);
         if (balance < this._transferAmount) {
-            throw (0, errors_1.insufficientBalanceError)(this._tokenAddress.toString());
+            throw (0, errors_1.insufficientBalanceError)(this._tvmAddress.toString());
         }
     }
     async checkCanBeTransferedBy(userAddress) {

package/dist/assets/NFT.d.ts

@@ -30,7 +30,7 @@ export declare class NFT implements Asset {
     static getCollectionData(contractOpener: ContractOpener, collectionAddress: TVMAddress): Promise<{
         nextIndex: number;
         content: Cell;
-        ownerAddress: Address;
+        adminAddress: Address;
     }>;
     static getOrigin(configuration: IConfiguration, itemOrCollection: TVMAddress): Promise<Origin>;
     static getItemAddress(contractOpener: ContractOpener, collectionAddress: TVMAddress, index: bigint): Promise<string>;

package/dist/assets/NFT.js

@@ -98,8 +98,10 @@ class NFT {
         }
         else {
             const nftCollection = configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromConfig({
-                ownerAddress: ton_1.Address.parse(configuration.TONParams.crossChainLayerAddress),
-                content: (0, ton_1.beginCell)().endCell(),
+                adminAddress: (0, ton_1.address)(configuration.TONParams.crossChainLayerAddress),
+                newAdminAddress: null,
+                collectionContent: (0, ton_1.beginCell)().endCell(),
+                commonContent: (0, ton_1.beginCell)().endCell(),
                 nftItemCode: configuration.TONParams.nftItemCode,
                 originalAddress: collectionAddress,
             }, configuration.TONParams.nftCollectionCode));
@@ -142,11 +144,17 @@ class NFT {
         if (this._addresses.evmAddress) {
             return this._addresses.evmAddress;
         }
-        if (this.origin === Struct_1.Origin.TAC) {
-            this._addresses.evmAddress = await this._nftCollection.getOriginalAddress().toString();
+        const tvmNFTAddress = ton_1.Address.parse(this._addresses.collection).toString({ bounceable: true });
+        const { code: givenNFTCollection } = await this._configuration.TONParams.contractOpener.getContractState(ton_1.Address.parse(tvmNFTAddress));
+        if (givenNFTCollection &&
+            this._configuration.TONParams.nftCollectionCode.equals(ton_1.Cell.fromBoc(givenNFTCollection)[0])) {
+            const nftCollection = this._configuration.TONParams.contractOpener.open(wrappers_1.NFTCollection.createFromAddress((0, ton_1.address)(tvmNFTAddress)));
+            const evmAddress = await nftCollection.getOriginalAddress();
+            this._addresses.evmAddress = evmAddress.toString();
         }
         else {
-            this._addresses.evmAddress = await this._configuration.TACParams.tokenUtils.computeAddressERC721(this._nftCollection.address.toString({ bounceable: true }));
+            this._addresses.evmAddress =
+                await this._configuration.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
         }
         return this._addresses.evmAddress;
     }

package/dist/sdk/LiteSequencerClient.d.ts

@@ -3,6 +3,7 @@ export declare class LiteSequencerClient {
     private readonly endpoint;
     private readonly maxChunkSize;
     constructor(endpoint: string, maxChunkSize?: number);
+    getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
     getOperationType(operationId: string): Promise<OperationType>;
     getOperationId(transactionLinker: TransactionLinker): Promise<string>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;

package/dist/sdk/LiteSequencerClient.js

@@ -12,6 +12,24 @@ class LiteSequencerClient {
         this.endpoint = endpoint;
         this.maxChunkSize = maxChunkSize;
     }
+    async getOperationIdByTransactionHash(transactionHash) {
+        const isEthHash = /^0x[a-fA-F0-9]{64}$/.test(transactionHash);
+        const path = isEthHash ? 'tac/operation-id' : 'ton/operation-id';
+        try {
+            const response = await axios_1.default.get(new URL(path, this.endpoint).toString(), {
+                params: { transactionHash },
+            });
+            return response.data.response || '';
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                if (error.response?.status === 404) {
+                    return '';
+                }
+            }
+            throw (0, errors_1.operationFetchError)(`endpoint ${this.endpoint} failed to complete request`, error);
+        }
+    }
     async getOperationType(operationId) {
         try {
             const response = await axios_1.default.get(new URL('operation-type', this.endpoint).toString(), {

package/dist/sdk/OperationTracker.d.ts

@@ -6,6 +6,7 @@ export interface ILiteSequencerClientFactory {
 export interface ILiteSequencerClient {
     getOperationType(operationId: string): Promise<OperationType>;
     getOperationId(transactionLinker: TransactionLinker): Promise<string>;
+    getOperationIdByTransactionHash(transactionHash: string): Promise<string>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, chunkSize?: number): Promise<OperationIdsByShardsKey>;
     getStageProfilings(operationIds: string[], chunkSize?: number): Promise<ExecutionStagesByOperationId>;
     getOperationStatuses(operationIds: string[], chunkSize?: number): Promise<StatusInfosByOperationId>;
@@ -17,6 +18,7 @@ export declare class OperationTracker implements IOperationTracker {
     private readonly clients;
     private readonly logger;
     constructor(network: Network, customLiteSequencerEndpoints?: string[], logger?: ILogger, clientFactory?: ILiteSequencerClientFactory);
+    getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string>): Promise<string>;
     getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
     getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey>, chunkSize?: number): Promise<OperationIdsByShardsKey>;

package/dist/sdk/OperationTracker.js

@@ -22,6 +22,26 @@ class OperationTracker {
         this.clients = clientFactory.createClients(endpoints);
         this.logger = logger;
     }
+    async getOperationIdByTransactionHash(transactionHash, waitOptions) {
+        this.logger.debug(`Getting operation ID for transactionHash: ${(0, Utils_1.formatObjectForLogging)(transactionHash)}`);
+        const requestFn = async () => {
+            let lastError;
+            for (const client of this.clients) {
+                try {
+                    const id = await client.getOperationIdByTransactionHash(transactionHash);
+                    this.logger.debug(`Operation ID ${id == '' ? 'does not exist' : 'retrieved successfully'}`);
+                    return id;
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get OperationId by transactionHash using one of the endpoints`);
+                    lastError = error;
+                }
+            }
+            this.logger.error('All endpoints failed to get operation id by transactionHash');
+            throw (0, errors_1.allEndpointsFailedError)(lastError);
+        };
+        return waitOptions ? await (0, Utils_1.waitUntilSuccess)(waitOptions, requestFn) : await requestFn();
+    }
     async getOperationType(operationId, waitOptions) {
         this.logger.debug(`Getting operation type for ${(0, Utils_1.formatObjectForLogging)(operationId)}`);
         const requestFn = async () => {

package/dist/sdk/TacSdk.d.ts

@@ -1,8 +1,8 @@
 import { Wallet } from 'ethers';
 import type { SenderAbstraction } from '../sender';
-import { IConfiguration, ILogger } from '../structs/Services';
-import { Asset, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, OperationIdsByShardsKey, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
-export declare class TacSdk {
+import { IConfiguration, ILogger, ITacSDK } from '../structs/Services';
+import { Asset, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, NFTItemData, OperationIdsByShardsKey, SDKParams, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinkerWithOperationId, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
+export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     private readonly simulator;
     private readonly transactionManager;
@@ -21,4 +21,12 @@ export declare class TacSdk {
     isContractDeployedOnTVM(address: string): Promise<boolean>;
     simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
     simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
+    getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
+    getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
+    getNFTItemData(itemAddress: string): Promise<NFTItemData>;
+    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
+    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
 }

package/dist/sdk/TacSdk.js

@@ -34,6 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TacSdk = void 0;
+const assets_1 = require("../assets");
+const FT_1 = require("../assets/FT");
+const NFT_1 = require("../assets/NFT");
+const TON_1 = require("../assets/TON");
 const Struct_1 = require("../structs/Struct");
 const Configuration_1 = require("./Configuration");
 const Consts_1 = require("./Consts");
@@ -97,5 +101,54 @@ class TacSdk {
     async simulateTransactions(sender, txs) {
         return this.simulator.simulateTransactions(sender, txs);
     }
+    // Jetton methods
+    async getUserJettonWalletAddress(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserWalletAddress(userAddress);
+    }
+    async getUserJettonBalance(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserBalance(userAddress);
+    }
+    async getUserJettonBalanceExtended(userAddress, tokenAddress) {
+        const ft = await assets_1.AssetFactory.from(this.config, {
+            address: tokenAddress,
+            tokenType: Struct_1.AssetType.FT,
+        });
+        return ft.getUserBalanceExtended(userAddress);
+    }
+    // NFT methods
+    async getNFTItemData(itemAddress) {
+        return NFT_1.NFT.getItemData(this.config.TONParams.contractOpener, itemAddress);
+    }
+    // Address conversion methods
+    async getEVMTokenAddress(tvmTokenAddress) {
+        if (tvmTokenAddress === this.nativeTONAddress || tvmTokenAddress === '') {
+            return TON_1.TON.create(this.config).getEVMAddress();
+        }
+        return FT_1.FT.getEVMAddress(this.config, tvmTokenAddress);
+    }
+    async getTVMTokenAddress(evmTokenAddress) {
+        return FT_1.FT.getTVMAddress(this.config, evmTokenAddress);
+    }
+    async getTVMNFTAddress(evmNFTAddress, tokenId) {
+        return NFT_1.NFT.getTVMAddress(this.config, evmNFTAddress, tokenId === undefined ? undefined : BigInt(tokenId));
+    }
+    async getEVMNFTAddress(tvmNFTAddress, addressType) {
+        if (addressType === Struct_1.NFTAddressType.ITEM) {
+            const nft = await NFT_1.NFT.fromItem(this.config, tvmNFTAddress);
+            return nft.getEVMAddress();
+        }
+        else {
+            const nftCollection = await NFT_1.NFT.fromCollection(this.config, { collection: tvmNFTAddress, index: 0n });
+            return nftCollection.getEVMAddress();
+        }
+    }
 }
 exports.TacSdk = TacSdk;

package/dist/sdk/TransactionManager.js

@@ -137,10 +137,15 @@ class TransactionManager {
         return waitOptions
             ? {
                 sendTransactionResult,
-                operationId: await this.operationTracker.getOperationId(transactionLinker, {
+                operationId: await this.operationTracker
+                    .getOperationId(transactionLinker, {
                     ...waitOptions,
                     successCheck: (operationId) => !!operationId,
                     logger: this.logger,
+                })
+                    .catch((error) => {
+                    this.logger.error(`Error while waiting for operation ID: ${error}`);
+                    return undefined;
                 }),
                 ...transactionLinker,
             }

package/dist/structs/Services.d.ts

@@ -1,7 +1,8 @@
 import { mainnet, testnet } from '@tonappchain/artifacts';
+import { Wallet } from 'ethers';
 import type { SenderAbstraction } from '../sender';
 import { InternalTACParams, InternalTONParams } from './InternalStruct';
-import { Asset, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, ExecutionStages, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker, WaitOptions } from './Struct';
+import { Asset, CrossChainTransactionOptions, CrosschainTx, EvmProxyMsg, ExecutionFeeEstimationResult, ExecutionStages, ExecutionStagesByOperationId, Network, NFTAddressType, NFTItemData, OperationIdsByShardsKey, OperationType, SimplifiedStatuses, StatusInfo, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationRequest, TACSimulationResult, TransactionLinker, TransactionLinkerWithOperationId, UserWalletBalanceExtended, WaitOptions } from './Struct';
 export interface IConfiguration {
     readonly network: Network;
     readonly artifacts: typeof testnet | typeof mainnet;
@@ -31,6 +32,7 @@ export interface ISimulator {
 export interface IOperationTracker {
     getOperationType(operationId: string, waitOptions?: WaitOptions<OperationType>): Promise<OperationType>;
     getOperationId(transactionLinker: TransactionLinker, waitOptions?: WaitOptions<string>): Promise<string>;
+    getOperationIdByTransactionHash(transactionHash: string, waitOptions?: WaitOptions<string>): Promise<string>;
     getOperationIdsByShardsKeys(shardsKeys: string[], caller: string, waitOptions?: WaitOptions<OperationIdsByShardsKey>, chunkSize?: number): Promise<OperationIdsByShardsKey>;
     getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages>): Promise<ExecutionStages>;
     getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId>, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
@@ -38,3 +40,27 @@ export interface IOperationTracker {
     getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
     getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
 }
+export interface ITacSDK {
+    readonly config: IConfiguration;
+    get nativeTONAddress(): string;
+    nativeTACAddress(): Promise<string>;
+    get getTrustedTACExecutors(): string[];
+    get getTrustedTONExecutors(): string[];
+    closeConnections(): unknown;
+    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
+    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
+    bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: Asset[], tvmExecutorFee?: bigint): Promise<string>;
+    getUserJettonWalletAddress(userAddress: string, tokenAddress: string): Promise<string>;
+    getUserJettonBalance(userAddress: string, tokenAddress: string): Promise<bigint>;
+    getUserJettonBalanceExtended(userAddress: string, tokenAddress: string): Promise<UserWalletBalanceExtended>;
+    getNFTItemData(itemAddress: string): Promise<NFTItemData>;
+    getEVMTokenAddress(tvmTokenAddress: string): Promise<string>;
+    getTVMTokenAddress(evmTokenAddress: string): Promise<string>;
+    getTVMNFTAddress(evmNFTAddress: string, tokenId?: number | bigint): Promise<string>;
+    getEVMNFTAddress(tvmNFTAddress: string, addressType: NFTAddressType): Promise<string>;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}

package/dist/structs/Struct.d.ts

@@ -356,3 +356,18 @@ export declare enum Origin {
 }
 export type TVMAddress = string;
 export type EVMAddress = string;
+export type AssetFromFTArg = {
+    address: TVMAddress | EVMAddress;
+    tokenType: AssetType.FT;
+};
+export type AssetFromNFTCollectionArg = {
+    address: TVMAddress | EVMAddress;
+    tokenType: AssetType.NFT;
+    addressType: NFTAddressType.COLLECTION;
+    index: bigint;
+};
+export type AssetFromNFTItemArg = {
+    address: TVMAddress;
+    tokenType: AssetType.NFT;
+    addressType: NFTAddressType.ITEM;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonappchain/sdk",
-  "version": "0.7.0-rc7.1",
+  "version": "0.7.0-rc9",
   "repository": "https://github.com/TacBuild/tac-sdk.git",
   "author": "TAC. <developers@tac>",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "@aws-crypto/sha256-js": "^5.2.0",
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/ton": "15.1.0",
-    "@tonappchain/artifacts": "0.0.19-mainnet-rc2",
+    "@tonappchain/artifacts": "0.0.19-smart-accounts-4",
     "@tonappchain/ton-lite-client": "3.0.6",
     "@tonconnect/ui": "^2.0.11",
     "bn.js": "^5.2.1",