@tonappchain/sdk 0.7.0-rc7 → 0.7.0-rc8

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,18 +24,18 @@ 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);
         }
         if (addressType === Struct_1.NFTAddressType.COLLECTION) {
-            if (!index) {
+            if (index === undefined) {
                 throw (0, errors_1.indexRequiredError)(address);
             }
             return NFT_1.NFT.fromCollection(configuration, { collection: address, index });

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;

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),
@@ -64,9 +66,9 @@ class FT {
     }
     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 +80,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 +134,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 +165,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 +179,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 +196,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.js

@@ -142,11 +142,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/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

@@ -31,6 +31,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>;

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",
+  "version": "0.7.0-rc8",
   "repository": "https://github.com/TacBuild/tac-sdk.git",
   "author": "TAC. <developers@tac>",
   "license": "MIT",