@tonappchain/sdk 0.7.1 → 0.7.2-gas-price-0.1

package/dist/src/sdk/Configuration.js

@@ -78,7 +78,6 @@ class Configuration {
         const artifacts = network === Struct_1.Network.MAINNET ? artifacts_1.mainnet : network === Struct_1.Network.TESTNET ? artifacts_1.testnet : artifacts_1.dev;
         let provider;
         let settingsAddress;
-        let saFactoryAddress;
         if (network === Struct_1.Network.DEV) {
             if (!TACParams || !TACParams.provider) {
                 throw new Error('For dev network, a custom provider must be provided in TACParams');
@@ -87,16 +86,11 @@ class Configuration {
             if (!TACParams.settingsAddress) {
                 throw new Error('For dev network, a custom settings address must be provided in TACParams');
             }
-            settingsAddress = TACParams.settingsAddress;
-            if (!TACParams.saFactoryAddress) {
-                throw new Error('For dev network, a custom smart account factory address must be provided in TACParams');
-            }
-            saFactoryAddress = TACParams.saFactoryAddress;
+            settingsAddress = TACParams.settingsAddress.toString();
         }
         else {
             provider = TACParams?.provider ?? ethers_1.ethers.getDefaultProvider(artifacts.TAC_RPC_ENDPOINT);
-            settingsAddress = TACParams?.settingsAddress ?? artifacts.TAC_SETTINGS_ADDRESS;
-            saFactoryAddress = TACParams?.saFactoryAddress ?? artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS;
+            settingsAddress = TACParams?.settingsAddress?.toString() ?? artifacts.TAC_SETTINGS_ADDRESS;
         }
         Validator_1.Validator.validateEVMAddress(settingsAddress);
         const settingsAbi = artifacts.tac.compilationArtifacts.ISettings.abi;
@@ -123,7 +117,7 @@ class Configuration {
         const tokenUtilsAbi = artifacts.tac.compilationArtifacts.ITokenUtils.abi;
         const tokenUtils = new ethers_1.ethers.Contract(tokenUtilsAddress, tokenUtilsAbi, provider);
         const TacSAFactoryAbi = artifacts.tac.compilationArtifacts.ISAFactory.abi;
-        const smartAccountFactory = new ethers_1.ethers.Contract(saFactoryAddress, TacSAFactoryAbi, provider);
+        const smartAccountFactory = new ethers_1.ethers.Contract(artifacts.TAC_SMART_ACCOUNT_FACTORY_ADDRESS, TacSAFactoryAbi, provider);
         return {
             provider,
             settings,

package/dist/src/sdk/LiteSequencerClient.js

@@ -15,18 +15,10 @@ class LiteSequencerClient {
         const isEthHash = /^0x[a-fA-F0-9]{64}$/.test(transactionHash);
         const path = isEthHash ? 'tac/operation-id' : 'ton/operation-id';
         try {
-            if (isEthHash) {
-                const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
-                    params: { transactionHash },
-                });
-                return response.data.response?.operationId || '';
-            }
-            else {
-                const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
-                    params: { transactionHash },
-                });
-                return response.data.response || '';
-            }
+            const response = await this.httpClient.get(new URL(path, this.endpoint).toString(), {
+                params: { transactionHash },
+            });
+            return response.data.response || '';
         }
         catch (error) {
             if (error?.response?.status === 404) {

package/dist/src/sdk/Logger.d.ts

@@ -6,8 +6,8 @@ export declare class ConsoleLogger implements ILogger {
     error(...arg: unknown[]): void;
 }
 export declare class NoopLogger implements ILogger {
-    debug(..._arg: unknown[]): void;
-    info(..._arg: unknown[]): void;
-    warn(..._arg: unknown[]): void;
-    error(..._arg: unknown[]): void;
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
 }

package/dist/src/sdk/Logger.js

@@ -17,17 +17,9 @@ class ConsoleLogger {
 }
 exports.ConsoleLogger = ConsoleLogger;
 class NoopLogger {
-    debug(..._arg) {
-        void _arg;
-    }
-    info(..._arg) {
-        void _arg;
-    }
-    warn(..._arg) {
-        void _arg;
-    }
-    error(..._arg) {
-        void _arg;
-    }
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
 }
 exports.NoopLogger = NoopLogger;

package/dist/src/sdk/OperationTracker.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationTracker = exports.DefaultLiteSequencerClientFactory = void 0;
 const artifacts_1 = require("../../artifacts");
 const errors_1 = require("../errors");
-const instances_1 = require("../errors/instances");
 const Struct_1 = require("../structs/Struct");
 const LiteSequencerClient_1 = require("./LiteSequencerClient");
 const Logger_1 = require("./Logger");
@@ -240,9 +239,6 @@ class OperationTracker {
         return Struct_1.SimplifiedStatuses.SUCCESSFUL;
     }
     async convertCurrency(params, waitOptions) {
-        if (params.value <= 0n) {
-            throw instances_1.convertCurrencyNegativeOrZeroValueError;
-        }
         this.logger.debug(`Converting currency: ${(0, Utils_1.formatObjectForLogging)(params)}`);
         const requestFn = async () => {
             let lastError;

package/dist/src/sdk/Simulator.js

@@ -27,7 +27,7 @@ class Simulator {
         Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
         Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
         Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
-        const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
+        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
         const shardCount = aggregatedData.jettons.length || 1;
         const transactionLinker = (0, Utils_1.generateTransactionLinker)(sender.getSenderAddress(), shardCount);
         const tacSimulationParams = {

package/dist/src/sdk/TONTransactionManager.d.ts

@@ -1,17 +1,17 @@
 import { IConfiguration, ILogger, IOperationTracker, ISimulator, ITONTransactionManager } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { BatchCrossChainTx, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EvmProxyMsg, FeeParams, TransactionLinkerWithOperationId } from '../structs/Struct';
+import { CrosschainTx, EvmProxyMsg, OperationIdsByShardsKey, TransactionLinkerWithOperationId, WaitOptions } from '../structs/Struct';
 export declare class TONTransactionManager implements ITONTransactionManager {
     private readonly config;
     private readonly simulator;
     private readonly operationTracker;
     private readonly logger;
     constructor(config: IConfiguration, simulator: ISimulator, operationTracker: IOperationTracker, logger?: ILogger);
-    protected buildFeeParams(options: CrossChainTransactionOptions, evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<FeeParams>;
+    private buildFeeParams;
     private prepareCrossChainTransaction;
     private generateCrossChainMessages;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTx[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, tx: CrosschainTx, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTx[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
     private prepareBatchTransactions;
     private waitForOperationIds;
 }

package/dist/src/sdk/TONTransactionManager.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TONTransactionManager = void 0;
 const assets_1 = require("../assets");
 const errors_1 = require("../errors");
-const instances_1 = require("../errors/instances");
 const Consts_1 = require("./Consts");
 const Logger_1 = require("./Logger");
 const Utils_1 = require("./Utils");
@@ -54,7 +53,7 @@ class TONTransactionManager {
         const { allowSimulationError = false, isRoundTrip = undefined, calculateRollbackFee = true, validateAssetsBalance = true, } = options || {};
         const { evmValidExecutors = [], tvmValidExecutors = [] } = options || {};
         Validator_1.Validator.validateEVMAddress(evmProxyMsg.evmTargetAddress);
-        const aggregatedData = (0, Utils_1.aggregateTokens)(assets);
+        const aggregatedData = await (0, Utils_1.aggregateTokens)(assets);
         Validator_1.Validator.validateEVMAddresses(evmValidExecutors);
         Validator_1.Validator.validateTVMAddresses(tvmValidExecutors);
         const shouldValidateAssets = validateAssetsBalance && !skipAssetsBalanceValidation;
@@ -137,44 +136,35 @@ class TONTransactionManager {
         this.logger.debug('Cross-chain messages generated successfully');
         return messages;
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, tx) {
+    async sendCrossChainTransaction(evmProxyMsg, sender, tx, waitOptions) {
         const { transaction, transactionLinker } = await this.prepareCrossChainTransaction(evmProxyMsg, sender, tx.assets, tx.options);
         await assets_1.TON.checkBalance(sender, this.config, [transaction]);
         this.logger.debug(`Sending transaction: ${(0, Utils_1.formatObjectForLogging)(transactionLinker)}`);
         const sendTransactionResult = await sender.sendShardTransaction(transaction, this.config.network, this.config.TONParams.contractOpener);
-        if (!sendTransactionResult.success || sendTransactionResult.error) {
-            throw (0, instances_1.sendCrossChainTransactionFailedError)(sendTransactionResult.error?.message ?? 'Transaction failed to send');
-        }
-        const shouldWaitForOperationId = tx.options?.waitOperationId ?? true;
-        if (!shouldWaitForOperationId) {
+        if (!waitOptions) {
             return { sendTransactionResult, ...transactionLinker };
         }
-        const waitOptions = tx.options?.waitOptions ?? {};
-        waitOptions.successCheck = waitOptions.successCheck ?? ((id) => !!id);
-        waitOptions.logger = waitOptions.logger ?? this.logger;
         const operationId = await this.operationTracker
-            .getOperationId(transactionLinker, waitOptions)
+            .getOperationId(transactionLinker, {
+            ...waitOptions,
+            successCheck: (id) => !!id,
+            logger: this.logger,
+        })
             .catch((error) => {
             this.logger.error(`Error while waiting for operation ID: ${error}`);
             return undefined;
         });
         return { sendTransactionResult, operationId, ...transactionLinker };
     }
-    async sendCrossChainTransactions(sender, txs, options) {
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
         const caller = sender.getSenderAddress();
         this.logger.debug(`Preparing ${txs.length} cross-chain transactions for ${caller}`);
         const { transactions, transactionLinkers } = await this.prepareBatchTransactions(txs, sender);
         await assets_1.TON.checkBalance(sender, this.config, transactions);
         this.logger.debug(`Sending transactions: ${(0, Utils_1.formatObjectForLogging)(transactionLinkers)}`);
-        const results = await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
-        for (const result of results) {
-            if (!result.success || result.error) {
-                throw (0, instances_1.sendCrossChainTransactionFailedError)(result.error?.message ?? 'Transaction failed to send');
-            }
-        }
-        const shouldWaitForOperationIds = options?.waitOperationIds ?? true;
-        return shouldWaitForOperationIds
-            ? await this.waitForOperationIds(transactionLinkers, caller, options?.waitOptions ?? {})
+        await sender.sendShardTransactions(transactions, this.config.network, this.config.TONParams.contractOpener);
+        return waitOptions
+            ? await this.waitForOperationIds(transactionLinkers, caller, waitOptions)
             : transactionLinkers;
     }
     async prepareBatchTransactions(txs, sender) {
@@ -183,7 +173,7 @@ class TONTransactionManager {
         if (txsRequiringValidation.length) {
             // Aggregate only assets from txs that require validation and validate once per unique asset
             const assetsToValidate = txsRequiringValidation.flatMap((tx) => tx.assets ?? []);
-            const aggregatedData = (0, Utils_1.aggregateTokens)(assetsToValidate);
+            const aggregatedData = await (0, Utils_1.aggregateTokens)(assetsToValidate);
             await Promise.all([
                 ...aggregatedData.jettons.map((jetton) => jetton.checkCanBeTransferredBy(caller)),
                 ...aggregatedData.nfts.map((nft) => nft.checkCanBeTransferredBy(caller)),
@@ -199,12 +189,12 @@ class TONTransactionManager {
     async waitForOperationIds(transactionLinkers, caller, waitOptions) {
         this.logger.debug(`Waiting for operation IDs`);
         try {
-            waitOptions.successCheck =
-                waitOptions.successCheck ??
-                    ((operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
-                        Object.values(operationIds).every((ids) => ids.operationIds.length > 0));
-            waitOptions.logger = waitOptions.logger ?? this.logger;
-            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, waitOptions);
+            const operationIds = await this.operationTracker.getOperationIdsByShardsKeys(transactionLinkers.map((linker) => linker.shardsKey), caller, {
+                ...waitOptions,
+                logger: this.logger,
+                successCheck: (operationIds) => Object.keys(operationIds).length == transactionLinkers.length &&
+                    Object.values(operationIds).every((ids) => ids.operationIds.length > 0),
+            });
             this.logger.debug(`Operation IDs: ${(0, Utils_1.formatObjectForLogging)(operationIds)}`);
             return transactionLinkers.map((linker) => ({
                 ...linker,

package/dist/src/sdk/TacSdk.d.ts

@@ -3,7 +3,7 @@ import { JettonMinterData, NFTItemData } from '../../artifacts/tonTypes';
 import { FT, NFT } from '../assets';
 import { IConfiguration, ILogger, IOperationTracker, ITacSDK } from '../interfaces';
 import type { SenderAbstraction } from '../sender';
-import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, BatchCrossChainTxWithAssetLike, CrossChainTransactionOptions, CrossChainTransactionsOptions, CrosschainTx, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended } from '../structs/Struct';
+import { AssetFromFTArg, AssetFromNFTCollectionArg, AssetFromNFTItemArg, AssetLike, CrossChainTransactionOptions, CrosschainTx, CrosschainTxWithAssetLike, EVMAddress, EvmProxyMsg, ExecutionFeeEstimationResult, NFTAddressType, OperationIdsByShardsKey, SDKParams, SuggestedTVMExecutorFee, TACSimulationParams, TACSimulationResult, TransactionLinkerWithOperationId, TVMAddress, UserWalletBalanceExtended, WaitOptions } from '../structs/Struct';
 export declare class TacSdk implements ITacSDK {
     readonly config: IConfiguration;
     readonly operationTracker: IOperationTracker;
@@ -20,8 +20,8 @@ export declare class TacSdk implements ITacSDK {
     get getTrustedTONExecutors(): string[];
     getSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<ExecutionFeeEstimationResult>;
     getTVMExecutorFeeInfo(assets: AssetLike[], feeSymbol: string, tvmValidExecutors?: string[]): Promise<SuggestedTVMExecutorFee>;
-    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions): Promise<TransactionLinkerWithOperationId>;
-    sendCrossChainTransactions(sender: SenderAbstraction, txs: BatchCrossChainTxWithAssetLike[], options?: CrossChainTransactionsOptions): Promise<TransactionLinkerWithOperationId[]>;
+    sendCrossChainTransaction(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: AssetLike[], options?: CrossChainTransactionOptions, waitOptions?: WaitOptions<string>): Promise<TransactionLinkerWithOperationId>;
+    sendCrossChainTransactions(sender: SenderAbstraction, txs: CrosschainTxWithAssetLike[], waitOptions?: WaitOptions<OperationIdsByShardsKey>): Promise<TransactionLinkerWithOperationId[]>;
     bridgeTokensToTON(signer: Wallet, value: bigint, tonTarget: string, assets?: AssetLike[], tvmExecutorFee?: bigint, tvmValidExecutors?: string[]): Promise<string>;
     isContractDeployedOnTVM(address: string): Promise<boolean>;
     simulateTACMessage(req: TACSimulationParams): Promise<TACSimulationResult>;

package/dist/src/sdk/TacSdk.js

@@ -77,18 +77,18 @@ class TacSdk {
         };
         return this.operationTracker.getTVMExecutorFee(params);
     }
-    async sendCrossChainTransaction(evmProxyMsg, sender, assets = [], options) {
+    async sendCrossChainTransaction(evmProxyMsg, sender, assets = [], options, waitOptions) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);
         const tx = { evmProxyMsg, assets: normalizedAssets, options };
-        return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx);
+        return this.tonTransactionManager.sendCrossChainTransaction(evmProxyMsg, sender, tx, waitOptions);
     }
-    async sendCrossChainTransactions(sender, txs, options) {
+    async sendCrossChainTransactions(sender, txs, waitOptions) {
         const normalizedTxs = await Promise.all(txs.map(async (tx) => ({
             evmProxyMsg: tx.evmProxyMsg,
             options: tx.options,
             assets: await (0, Utils_1.normalizeAssets)(this.config, tx.assets),
         })));
-        return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, options);
+        return this.tonTransactionManager.sendCrossChainTransactions(sender, normalizedTxs, waitOptions);
     }
     async bridgeTokensToTON(signer, value, tonTarget, assets, tvmExecutorFee, tvmValidExecutors) {
         const normalizedAssets = await (0, Utils_1.normalizeAssets)(this.config, assets);

package/dist/src/sdk/TxFinalizer.js

@@ -46,9 +46,6 @@ class TonTxFinalizer {
                 const errorMessage = error.message;
                 // Rate limit error (429) - retry
                 if (errorMessage.includes('429')) {
-                    if (i > 0) {
-                        await (0, Utils_1.sleep)(delay);
-                    }
                     continue;
                 }
                 // Log all errors except 404 Not Found
@@ -56,10 +53,8 @@ class TonTxFinalizer {
                     const logMessage = error instanceof Error ? error.message : error;
                     console.warn(`Failed to fetch adjacent transactions for ${hash}:`, logMessage);
                 }
-                if (i > 0) {
-                    await (0, Utils_1.sleep)(delay);
-                }
             }
+            await (0, Utils_1.sleep)(delay);
         }
         return [];
     }

package/dist/src/sdk/Utils.d.ts

@@ -20,11 +20,11 @@ export declare const generateFeeData: (feeParams?: FeeParams) => Cell | undefine
 export declare function waitUntilSuccess<T, TContext = unknown, A extends unknown[] = unknown[]>(options: WaitOptions<T, TContext> | undefined, operation: (...args: A) => Promise<T>, operationDescription?: string, ...args: A): Promise<T>;
 export declare function formatObjectForLogging(obj: unknown): string;
 export declare function getBouncedAddress(tvmAddress: string): string;
-export declare function aggregateTokens(assets?: Asset[]): {
+export declare function aggregateTokens(assets?: Asset[]): Promise<{
     jettons: FT[];
     nfts: NFT[];
     ton?: TON;
-};
+}>;
 export declare function sha256toBigInt(ContractName: string): bigint;
 export declare function mapAssetsToTonAssets(assets: Asset[]): TONAsset[];
 export declare function normalizeAsset(config: IConfiguration, input: AssetLike): Promise<Asset>;

package/dist/src/sdk/Utils.js

@@ -199,30 +199,39 @@ function getBouncedAddress(tvmAddress) {
         bounceable: true,
     });
 }
-function aggregateTokens(assets) {
-    const jettonsMap = new Map();
-    const nftsMap = new Map();
+async function aggregateTokens(assets) {
+    const uniqueAssetsMap = new Map();
     let ton;
-    for (const asset of assets ?? []) {
-        if (asset.rawAmount === 0n && asset.type === Struct_1.AssetType.FT) {
+    for await (const asset of assets ?? []) {
+        if (asset.type !== Struct_1.AssetType.FT)
+            continue;
+        if (asset.rawAmount === 0n) {
             throw (0, errors_1.zeroRawAmountError)(asset.address || 'NATIVE TON');
         }
-        if (asset.type === Struct_1.AssetType.FT) {
-            if (!asset.address) {
-                ton = ton ? ton.addRawAmount(asset.rawAmount) : asset.clone;
-            }
-            else {
-                const existing = jettonsMap.get(asset.address);
-                jettonsMap.set(asset.address, (existing ? existing.addRawAmount(asset.rawAmount) : asset.clone));
-            }
+        if (!asset.address) {
+            ton = ton ? ton.addRawAmount(asset.rawAmount) : asset.clone;
+            continue;
         }
-        else if (asset.type === Struct_1.AssetType.NFT) {
-            nftsMap.set(asset.address, asset.clone);
+        let jetton = uniqueAssetsMap.get(asset.address);
+        if (!jetton) {
+            jetton = asset.clone;
         }
+        else {
+            jetton = jetton.addRawAmount(asset.rawAmount);
+        }
+        uniqueAssetsMap.set(asset.address, jetton);
+    }
+    const jettons = Array.from(uniqueAssetsMap.values());
+    uniqueAssetsMap.clear();
+    for await (const asset of assets ?? []) {
+        if (asset.type !== Struct_1.AssetType.NFT)
+            continue;
+        uniqueAssetsMap.set(asset.address, asset.clone);
     }
+    const nfts = Array.from(uniqueAssetsMap.values());
     return {
-        jettons: Array.from(jettonsMap.values()),
-        nfts: Array.from(nftsMap.values()),
+        jettons,
+        nfts,
         ton,
     };
 }
@@ -231,11 +240,7 @@ function sha256toBigInt(ContractName) {
     return BigInt('0x' + hash.toString('hex'));
 }
 function mapAssetsToTonAssets(assets) {
-    const { jettons, nfts, ton } = aggregateTokens(assets);
-    const result = [...jettons, ...nfts];
-    if (ton)
-        result.push(ton);
-    return result.map((asset) => ({
+    return assets.map((asset) => ({
         amount: asset.rawAmount.toString(),
         tokenAddress: asset.address || '',
         assetType: asset.type,
@@ -263,15 +268,9 @@ async function normalizeAsset(config, input) {
         const asset = await assets_1.AssetFactory.from(config, ftArgs);
         const rawAmount = 'rawAmount' in input ? input.rawAmount : undefined;
         const amount = 'amount' in input ? input.amount : 0;
-        if (!rawAmount && !amount && asset.type === Struct_1.AssetType.FT) {
-            throw (0, errors_1.zeroRawAmountError)(asset.address || 'NATIVE TON');
-        }
         return rawAmount ? asset.withRawAmount(rawAmount) : asset.withAmount(amount);
     }
     catch (e) {
-        if (e instanceof errors_1.TokenError && e.errorCode === (0, errors_1.zeroRawAmountError)('').errorCode) {
-            throw e;
-        }
         console.warn('Failed to normalize FT asset', e);
     }
     const itemArgs = {

package/dist/src/sender/SenderFactory.js

@@ -38,7 +38,7 @@ class SenderFactory {
         if (params.version === 'V5R1') {
             // manual setup of wallet id required to support wallet w5 both on mainnet and testnet
             config.walletId = {
-                networkGlobalId: params.network === Struct_1.Network.MAINNET ? -239 : -3,
+                networkGlobalId: params.network === Struct_1.Network.TESTNET ? -3 : -239,
                 context: {
                     walletVersion: 'v5r1',
                     workchain: 0,

package/dist/src/sender/TonConnectSender.js

@@ -28,7 +28,7 @@ class TonConnectSender {
             const transaction = {
                 validUntil,
                 messages: chunk,
-                network: chain == Struct_1.Network.MAINNET ? ui_1.CHAIN.MAINNET : ui_1.CHAIN.TESTNET,
+                network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
             };
             try {
                 const response = await this.tonConnect.sendTransaction(transaction);

package/dist/src/structs/InternalStruct.d.ts

@@ -54,11 +54,6 @@ export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
 export type SuggestedTVMExecutorFeeResponse = ResponseBase<SuggestedTVMExecutorFee>;
 export type ConvertCurrencyResponse = ResponseBase<ConvertedCurrencyRawResult>;
-export type OperationIdWithLogIndex = {
-    operationId: string;
-    logIndex: number;
-};
-export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex>;
 export interface SendResult {
     success: boolean;
     result?: unknown;

package/dist/src/structs/Struct.d.ts

@@ -1,6 +1,6 @@
 import { SandboxContract } from '@ton/sandbox';
 import { OpenedContract } from '@ton/ton';
-import { AbstractProvider } from 'ethers';
+import { AbstractProvider, Addressable } from 'ethers';
 import { JettonMinter, JettonMinterData } from '../../artifacts/tonTypes';
 import type { FT, NFT } from '../assets';
 import type { Asset, ContractOpener, ILogger } from '../interfaces';
@@ -44,11 +44,7 @@ export type TACParams = {
     /**
      * Address of TAC settings contract. Use only for tests.
      */
-    settingsAddress?: string;
-    /**
-     * Address of TAC smart account factory contract. Use only for tests.
-     */
-    saFactoryAddress?: string;
+    settingsAddress?: string | Addressable;
 };
 export type TONParams = {
     /**
@@ -291,13 +287,6 @@ export type CrossChainTransactionOptions = {
     calculateRollbackFee?: boolean;
     withoutSimulation?: boolean;
     validateAssetsBalance?: boolean;
-    waitOperationId?: boolean;
-    waitOptions?: WaitOptions<string>;
-};
-export type BatchCrossChainTransactionOptions = Omit<CrossChainTransactionOptions, 'waitOperationId' | 'waitOptions'>;
-export type CrossChainTransactionsOptions = {
-    waitOperationIds?: boolean;
-    waitOptions?: WaitOptions<OperationIdsByShardsKey>;
 };
 export type ExecutionFeeEstimationResult = {
     feeParams: FeeParams;
@@ -308,11 +297,6 @@ export type CrosschainTx = {
     assets?: Asset[];
     options?: CrossChainTransactionOptions;
 };
-export type BatchCrossChainTx = {
-    evmProxyMsg: EvmProxyMsg;
-    assets?: Asset[];
-    options?: BatchCrossChainTransactionOptions;
-};
 export type AssetLike = Asset | FT | NFT | {
     rawAmount: bigint;
 } | {
@@ -329,7 +313,7 @@ export type AssetLike = Asset | FT | NFT | {
     address: TVMAddress | EVMAddress;
     itemIndex: bigint;
 };
-export type BatchCrossChainTxWithAssetLike = Omit<BatchCrossChainTx, 'assets'> & {
+export type CrosschainTxWithAssetLike = Omit<CrosschainTx, 'assets'> & {
     assets?: AssetLike[];
 };
 export interface WaitOptions<T = unknown, TContext = unknown> {