@tonappchain/sdk 0.6.1-v3.0.4 → 0.6.1

package/dist/sdk/TacSdk.js

@@ -20,7 +20,6 @@ const Consts_1 = require("./Consts");
 const Utils_1 = require("./Utils");
 const artifacts_1 = require("@tonappchain/artifacts");
 const errors_1 = require("../errors");
-const contractOpener_1 = require("../adapters/contractOpener");
 const wrappers_1 = require("@tonappchain/artifacts/dist/src/ton/wrappers");
 const instances_1 = require("../errors/instances");
 class TacSdk {
@@ -45,7 +44,12 @@ class TacSdk {
         return new TacSdk(network, delay, artifacts, TONParams, TACParams, liteSequencerEndpoints);
     }
     static async prepareTONParams(network, delay, artifacts, TONParams) {
-        const contractOpener = TONParams?.contractOpener ?? (await (0, contractOpener_1.orbsOpener4)(network));
+        const contractOpener = TONParams?.contractOpener ??
+            new ton_1.TonClient({
+                endpoint: network == Struct_1.Network.TESTNET
+                    ? new URL('api/v2/jsonRPC', artifacts_1.testnet.TON_RPC_ENDPOINT_BY_TAC).toString()
+                    : artifacts_1.mainnet.TON_PUBLIC_RPC_ENDPOINT,
+            });
         const settingsAddress = TONParams?.settingsAddress ?? artifacts.ton.addresses.TON_SETTINGS_ADDRESS;
         const settings = contractOpener.open(new Settings_1.Settings(ton_1.Address.parse(settingsAddress)));
         const jettonProxyAddress = await settings.getAddressSetting('JettonProxyAddress');
@@ -169,24 +173,9 @@ class TacSdk {
             .endCell();
         return wrappers_1.NFTItem.transferMessage(queryId, (0, ton_1.address)(transferData.to ?? this.TONParams.nftProxyAddress), (0, ton_1.address)(transferData.responseAddress), Number((0, ton_1.fromNano)(Consts_1.NFT_TRANSFER_FORWARD_TON_AMOUNT + forwardFeeAmount + crossChainTonAmount)), forwardPayload);
     }
-    generateFeeData(feeParams) {
-        if (feeParams) {
-            let feeDataBuilder = (0, ton_1.beginCell)()
-                .storeBit(feeParams.isRoundTrip)
-                .storeCoins(feeParams.protocolFee)
-                .storeCoins(feeParams.evmExecutorFee);
-            if (feeParams.isRoundTrip) {
-                feeDataBuilder.storeCoins(feeParams.tvmExecutorFee);
-            }
-            return feeDataBuilder.endCell();
-        }
-        else {
-            return undefined;
-        }
-    }
     getTonTransferPayload(responseAddress, evmData, crossChainTonAmount, feeParams) {
         const queryId = (0, Utils_1.generateRandomNumberByTimestamp)().randomNumber;
-        const feeData = this.generateFeeData(feeParams);
+        const feeData = (0, Utils_1.generateFeeData)(feeParams);
         return (0, ton_1.beginCell)()
             .storeUint(this.artifacts.ton.wrappers.CrossChainLayerOpCodes.anyone_tvmMsgToEVM, 32)
             .storeUint(queryId, 64)
@@ -288,7 +277,7 @@ class TacSdk {
         const opType = await this.getJettonOpType(jetton);
         await (0, Utils_1.sleep)(this.delay * 1000);
         console.log(`***** Jetton ${jetton.address} requires ${opType} operation`);
-        const feeData = this.generateFeeData(feeParams);
+        const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;
         switch (opType) {
             case InternalStruct_1.AssetOpType.JETTON_BURN:
@@ -307,7 +296,7 @@ class TacSdk {
         const opType = await this.getNFTOpType(nft);
         await (0, Utils_1.sleep)(this.delay * 1000);
         console.log(`***** NFT ${nft.address} requires ${opType} operation`);
-        const feeData = this.generateFeeData(feeParams);
+        const feeData = (0, Utils_1.generateFeeData)(feeParams);
         let payload;
         switch (opType) {
             case InternalStruct_1.AssetOpType.NFT_BURN:
@@ -391,6 +380,7 @@ class TacSdk {
         (0, Utils_1.validateTVMAddress)(precalculatedAddress);
         const contract = this.TONParams.contractOpener.open(new JettonMaster_1.JettonMaster((0, ton_1.address)(precalculatedAddress)));
         const { content } = await contract.getJettonData();
+        await (0, Utils_1.sleep)(this.delay * 1000);
         if (!content.metadata.decimals) {
             // if decimals not specified use default value 9
             return (0, ton_1.toNano)(asset.amount);
@@ -414,6 +404,7 @@ class TacSdk {
                     const address = (0, ethers_1.isAddress)(asset.collectionAddress)
                         ? await this.getTVMNFTAddress(asset.collectionAddress, asset.itemIndex)
                         : await this.getNFTItemAddressTON(asset.collectionAddress, asset.itemIndex);
+                    await (0, Utils_1.sleep)(this.delay * 1000);
                     return {
                         address,
                         rawAmount: 1n,
@@ -441,7 +432,6 @@ class TacSdk {
             },
             evmValidExecutors: evmValidExecutors,
             extraData: '0x',
-            feeAssetAddress: '',
             shardsKey: transactionLinker.shardsKey,
             tonAssets: rawAssets.map((asset) => ({
                 amount: asset.rawAmount.toString(),
@@ -491,6 +481,29 @@ class TacSdk {
         const evmValidExecutors = this.TACParams.trustedTACExecutors;
         return await this.getFeeInfo(evmProxyMsg, transactionLinker, rawAssets, evmValidExecutors, false, undefined);
     }
+    async getTVMExecutorFeeInfo(assets, feeSymbol) {
+        const rawAssets = await this.convertAssetsToRawFormat(assets);
+        const requestBody = {
+            tonAssets: rawAssets.map((asset) => ({
+                amount: asset.rawAmount.toString(),
+                tokenAddress: asset.address || '',
+                assetType: asset.type,
+            })),
+            feeSymbol: feeSymbol,
+        };
+        let lastError;
+        for (const endpoint of this.liteSequencerEndpoints) {
+            try {
+                const response = await axios_1.default.post(`${endpoint}/ton/calculator/ton-executor-fee`, requestBody);
+                return response.data.response;
+            }
+            catch (error) {
+                console.error(`Error while calculating tvm executor fee ${endpoint}:`, error);
+                lastError = error;
+            }
+        }
+        throw (0, errors_1.simulationError)(lastError);
+    }
     async prepareCrossChainTransaction(evmProxyMsg, caller, assets, options) {
         let { forceSend = false, isRoundTrip = undefined, protocolFee = undefined, evmValidExecutors = [], evmExecutorFee = undefined, tvmValidExecutors = [], tvmExecutorFee = undefined, } = options || {};
         const rawAssets = await this.convertAssetsToRawFormat(assets);
@@ -556,6 +569,34 @@ class TacSdk {
         if (assets == undefined) {
             assets = [];
         }
+        let tonAssets = [];
+        for (const asset of assets) {
+            if (asset.type == Struct_1.AssetType.FT) {
+                const tvmAddress = await this.getTVMTokenAddress(asset.address);
+                tonAssets.push({
+                    address: tvmAddress,
+                    rawAmount: asset.rawAmount,
+                    type: Struct_1.AssetType.FT,
+                });
+            }
+            else {
+                const nftItemAddress = await this.getTVMNFTAddress(asset.collectionAddress, asset.itemIndex);
+                tonAssets.push({
+                    address: nftItemAddress,
+                    amount: 1,
+                    type: Struct_1.AssetType.NFT,
+                });
+            }
+        }
+        if (value > 0) {
+            const tvmAddress = await this.getTVMTokenAddress(await this.nativeTACAddress());
+            tonAssets.push({
+                address: tvmAddress,
+                rawAmount: value,
+                type: Struct_1.AssetType.FT,
+            });
+        }
+        const suggestedTONExecutorFee = await this.getTVMExecutorFeeInfo(tonAssets, Consts_1.TAC_SYMBOL);
         const crossChainLayerAddress = await this.TACParams.crossChainLayer.getAddress();
         for (const asset of assets) {
             if (asset.type == Struct_1.AssetType.FT) {
@@ -571,27 +612,12 @@ class TacSdk {
         }
         const shardsKey = BigInt(Math.round(Math.random() * 1e18));
         const protocolFee = await this.TACParams.crossChainLayer.getProtocolFee();
-        let tvmExecutorFeeInTON = 0n;
-        if (tvmExecutorFee != undefined) {
-            tvmExecutorFeeInTON = tvmExecutorFee;
-        }
-        else {
-            tvmExecutorFeeInTON =
-                ((((0, ton_1.toNano)('0.065') + (0, ton_1.toNano)('0.05')) * BigInt(assets.length + 1 + Number(value != 0n)) +
-                    (0, ton_1.toNano)('0.2')) *
-                    120n) /
-                    100n; // TODO calc that
-        }
-        const tonToTacRate = 100n;
-        const scale = 10n ** 9n;
-        const tonToTacRateScaled = tonToTacRate * scale;
-        const tvmExecutorFeeInTAC = tonToTacRateScaled * tvmExecutorFeeInTON;
         const outMessage = {
             shardsKey: shardsKey,
             tvmTarget: tonTarget,
             tvmPayload: '',
             tvmProtocolFee: protocolFee,
-            tvmExecutorFee: tvmExecutorFeeInTAC,
+            tvmExecutorFee: tvmExecutorFee ?? BigInt(suggestedTONExecutorFee.inTAC),
             tvmValidExecutors: this.TACParams.trustedTONExecutors,
             toBridge: assets
                 .filter((asset) => asset.type === Struct_1.AssetType.FT)
@@ -690,24 +716,26 @@ class TacSdk {
             await (0, Utils_1.sleep)(this.delay * 1000);
             return evmAddress.toString();
         }
-        return this.TACParams.tokenUtils.computeAddress(tvmNFTAddress);
+        return this.TACParams.tokenUtils.computeAddressERC721(tvmNFTAddress);
     }
     async isContractDeployedOnTVM(address) {
         return (await this.TONParams.contractOpener.getContractState(ton_1.Address.parse(address))).state === 'active';
     }
     async simulateTACMessage(req) {
+        let lastError;
         for (const endpoint of this.liteSequencerEndpoints) {
             try {
-                const response = await axios_1.default.post(`${endpoint}/tac/simulator/simulate-message`, req, {
+                const response = await axios_1.default.post(new URL('tac/simulator/simulate-message', endpoint).toString(), req, {
                     transformResponse: [Utils_1.toCamelCaseTransformer],
                 });
                 return response.data.response;
             }
             catch (error) {
                 console.error(`Error while simulating with ${endpoint}:`, error);
+                lastError = error;
             }
         }
-        throw errors_1.simulationError;
+        throw (0, errors_1.simulationError)(lastError);
     }
 }
 exports.TacSdk = TacSdk;

package/dist/sdk/Utils.d.ts

@@ -1,6 +1,6 @@
 import { Address, Cell } from '@ton/ton';
 import { AbiCoder } from 'ethers';
-import { EvmProxyMsg, TransactionLinker, ValidExecutors } from '../structs/Struct';
+import { EvmProxyMsg, FeeParams, TransactionLinker, ValidExecutors } from '../structs/Struct';
 import { RandomNumberByTimestamp } from '../structs/InternalStruct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export declare function generateRandomNumber(interval: number): number;
@@ -16,3 +16,4 @@ export declare const convertKeysToCamelCase: <T>(data: T) => T;
 export declare const calculateRawAmount: (amount: number, decimals: number) => bigint;
 export declare const calculateAmount: (rawAmount: bigint, decimals: number) => number;
 export declare const toCamelCaseTransformer: (data: any) => any;
+export declare const generateFeeData: (feeParams?: FeeParams) => Cell | undefined;

package/dist/sdk/Utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCamelCaseTransformer = exports.calculateAmount = exports.calculateRawAmount = exports.convertKeysToCamelCase = exports.sleep = void 0;
+exports.generateFeeData = exports.toCamelCaseTransformer = exports.calculateAmount = exports.calculateRawAmount = exports.convertKeysToCamelCase = exports.sleep = void 0;
 exports.generateRandomNumber = generateRandomNumber;
 exports.generateRandomNumberByTimestamp = generateRandomNumberByTimestamp;
 exports.calculateContractAddress = calculateContractAddress;
@@ -126,3 +126,19 @@ const toCamelCaseTransformer = (data) => {
     }
 };
 exports.toCamelCaseTransformer = toCamelCaseTransformer;
+const generateFeeData = (feeParams) => {
+    if (feeParams) {
+        let feeDataBuilder = (0, ton_1.beginCell)()
+            .storeBit(feeParams.isRoundTrip)
+            .storeCoins(feeParams.protocolFee)
+            .storeCoins(feeParams.evmExecutorFee);
+        if (feeParams.isRoundTrip) {
+            feeDataBuilder.storeCoins(feeParams.tvmExecutorFee);
+        }
+        return feeDataBuilder.endCell();
+    }
+    else {
+        return undefined;
+    }
+};
+exports.generateFeeData = generateFeeData;

package/dist/sender/BatchSender.d.ts

@@ -0,0 +1,15 @@
+import type { ContractOpener } from '../structs/Struct';
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import { Network } from '../structs/Struct';
+import { SenderAbstraction } from './SenderAbstraction';
+import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
+export declare class BatchSender implements SenderAbstraction {
+    private wallet;
+    private secretKey;
+    constructor(wallet: HighloadWalletV3, secretKey: Buffer);
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;
+    private prepareGroups;
+    private sendGroup;
+    getSenderAddress(): string;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult>;
+}

package/dist/sender/BatchSender.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchSender = void 0;
+const ton_1 = require("@ton/ton");
+const SenderAbstraction_1 = require("./SenderAbstraction");
+const Consts_1 = require("../sdk/Consts");
+const instances_1 = require("../errors/instances");
+class BatchSender {
+    constructor(wallet, secretKey) {
+        this.wallet = wallet;
+        this.secretKey = secretKey;
+    }
+    async sendShardTransactions(shardTransactions, delay, _chain, contractOpener) {
+        const allMessages = [];
+        let minValidUntil = Number.MAX_SAFE_INTEGER;
+        for (const transaction of shardTransactions) {
+            for (const message of transaction.messages) {
+                allMessages.push((0, ton_1.internal)({
+                    to: message.address,
+                    value: (0, ton_1.fromNano)(message.value),
+                    bounce: true,
+                    body: message.payload,
+                }));
+            }
+            minValidUntil = Math.min(minValidUntil, transaction.validUntil);
+        }
+        const groups = await this.prepareGroups(allMessages);
+        const results = [];
+        let currentMessageIndex = 0;
+        for (const group of groups) {
+            await (0, SenderAbstraction_1.sleep)(delay * 1000);
+            try {
+                const result = await this.sendGroup(group, contractOpener);
+                results.push({
+                    success: true,
+                    result,
+                    lastMessageIndex: currentMessageIndex + group.length - 1,
+                });
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    error: error,
+                    lastMessageIndex: currentMessageIndex - 1,
+                });
+                break; // Stop sending after first error
+            }
+            currentMessageIndex += group.length;
+        }
+        return results;
+    }
+    async prepareGroups(messages) {
+        const total = messages.length;
+        let left = 0;
+        const groups = [];
+        while (left < total) {
+            let groupSize = total - left;
+            if (groupSize > Consts_1.MAX_HIGHLOAD_GROUP_MSG_NUM) {
+                groupSize = Consts_1.MAX_HIGHLOAD_GROUP_MSG_NUM;
+            }
+            let validGroupFound = false;
+            while (groupSize > 0) {
+                const group = messages.slice(left, left + groupSize);
+                const createdAt = Math.floor(Date.now() / 1000) - 40;
+                const queryId = this.wallet.getQueryIdFromCreatedAt(createdAt);
+                const externalMsg = this.wallet.getExternalMessage(group, ton_1.SendMode.PAY_GAS_SEPARATELY, 0n, queryId);
+                const isBocSizeValid = externalMsg.body.toBoc().length <= Consts_1.MAX_EXT_MSG_SIZE;
+                const isDepthValid = externalMsg.body.depth() <= Consts_1.MAX_MSG_DEPTH;
+                if (isBocSizeValid && isDepthValid) {
+                    groups.push(group);
+                    left += groupSize;
+                    validGroupFound = true;
+                    break;
+                }
+                if (groupSize <= 1) {
+                    throw (0, instances_1.prepareMessageGroupError)(isBocSizeValid, isDepthValid);
+                }
+                groupSize = Math.floor(groupSize / 2);
+            }
+            if (!validGroupFound) {
+                throw instances_1.noValidGroupFoundError;
+            }
+        }
+        return groups;
+    }
+    async sendGroup(messages, contractOpener) {
+        const walletContract = contractOpener.open(this.wallet);
+        return walletContract.sendTransfer({
+            secretKey: this.secretKey,
+            messages,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+        });
+    }
+    getSenderAddress() {
+        return this.wallet.address.toString();
+    }
+    async sendShardTransaction(shardTransaction, delay, _chain, contractOpener) {
+        const messages = [];
+        for (const message of shardTransaction.messages) {
+            messages.push((0, ton_1.internal)({
+                to: message.address,
+                value: (0, ton_1.fromNano)(message.value),
+                bounce: true,
+                body: message.payload,
+            }));
+        }
+        await (0, SenderAbstraction_1.sleep)(delay * 1000);
+        const result = await this.sendGroup(messages, contractOpener);
+        return {
+            success: true,
+            result,
+            lastMessageIndex: shardTransaction.messages.length - 1,
+        };
+    }
+}
+exports.BatchSender = BatchSender;

package/dist/sender/RawSender.d.ts

@@ -1,14 +1,12 @@
 import type { ContractOpener } from '../structs/Struct';
-import type { ShardTransaction } from '../structs/InternalStruct';
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
 import { Network } from '../structs/Struct';
 import { SenderAbstraction, WalletInstance } from './SenderAbstraction';
 export declare class RawSender implements SenderAbstraction {
     private wallet;
     private secretKey;
     constructor(wallet: WalletInstance, secretKey: Buffer);
-    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain: Network, contractOpener: ContractOpener): Promise<unknown>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;
     getSenderAddress(): string;
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<void | (import("@ton/sandbox").SendMessageResult & {
-        result: void;
-    })>;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult>;
 }

package/dist/sender/RawSender.js

@@ -4,43 +4,34 @@ exports.RawSender = void 0;
 const ton_1 = require("@ton/ton");
 const ton_2 = require("@ton/ton");
 const SenderAbstraction_1 = require("./SenderAbstraction");
-const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
 class RawSender {
     constructor(wallet, secretKey) {
         this.wallet = wallet;
         this.secretKey = secretKey;
     }
     async sendShardTransactions(shardTransactions, delay, chain, contractOpener) {
-        const walletContract = contractOpener.open(this.wallet);
-        const isBatchSendSupported = walletContract instanceof HighloadWalletV3_1.HighloadWalletV3 || walletContract instanceof ton_1.WalletContractV5R1;
-        if (isBatchSendSupported) {
-            const messages = [];
-            for (const shardTx of shardTransactions) {
-                for (const message of shardTx.messages) {
-                    messages.push((0, ton_1.internal)({
-                        to: message.address,
-                        value: (0, ton_1.fromNano)(message.value),
-                        bounce: true,
-                        body: message.payload,
-                    }));
-                }
+        const results = [];
+        let currentMessageIndex = 0;
+        for (const shardTx of shardTransactions) {
+            try {
+                const result = await this.sendShardTransaction(shardTx, delay, chain, contractOpener);
+                results.push({
+                    success: true,
+                    result,
+                    lastMessageIndex: currentMessageIndex + shardTx.messages.length - 1,
+                });
+                currentMessageIndex += shardTx.messages.length;
             }
-            const seqno = await walletContract.getSeqno();
-            await (0, SenderAbstraction_1.sleep)(delay * 1000);
-            return walletContract.sendTransfer({
-                seqno,
-                secretKey: this.secretKey,
-                messages,
-                sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
-            });
-        }
-        else {
-            const results = [];
-            for (const shardTx of shardTransactions) {
-                results.push(await this.sendShardTransaction(shardTx, delay, chain, contractOpener));
+            catch (error) {
+                results.push({
+                    success: false,
+                    error: error,
+                    lastMessageIndex: currentMessageIndex - 1,
+                });
+                break; // Stop sending after first error
             }
-            return results;
         }
+        return results;
     }
     getSenderAddress() {
         return this.wallet.address.toString();
@@ -59,12 +50,17 @@ class RawSender {
             }));
         }
         await (0, SenderAbstraction_1.sleep)(delay * 1000);
-        return walletContract.sendTransfer({
+        const result = await walletContract.sendTransfer({
             seqno,
             secretKey: this.secretKey,
             messages,
             sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
         });
+        return {
+            success: true,
+            result,
+            lastMessageIndex: shardTransaction.messages.length - 1,
+        };
     }
 }
 exports.RawSender = RawSender;

package/dist/sender/SenderAbstraction.d.ts

@@ -1,6 +1,6 @@
 import type { Contract, ContractProvider, MessageRelaxed, SendMode } from '@ton/ton';
 import type { ContractOpener } from '../structs/Struct';
-import type { ShardTransaction } from '../structs/InternalStruct';
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
 import { Network } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export interface WalletInstance extends Contract {
@@ -14,7 +14,7 @@ export interface WalletInstance extends Contract {
     }): Promise<void>;
 }
 export interface SenderAbstraction {
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<unknown>;
-    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<unknown>;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
     getSenderAddress(): string;
 }

package/dist/sender/SenderFactory.js

@@ -5,6 +5,7 @@ const ton_1 = require("@ton/ton");
 const ton_crypto_1 = require("ton-crypto");
 const RawSender_1 = require("./RawSender");
 const TonConnectSender_1 = require("./TonConnectSender");
+const BatchSender_1 = require("./BatchSender");
 const errors_1 = require("../errors");
 const Struct_1 = require("../structs/Struct");
 const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
@@ -49,6 +50,9 @@ class SenderFactory {
             config.timeout = params.options?.highloadV3?.timeout ?? HighloadWalletV3_1.DEFAULT_TIMEOUT;
         }
         const wallet = exports.wallets[params.version].create(config);
+        if (params.version === 'HIGHLOAD_V3') {
+            return new BatchSender_1.BatchSender(wallet, keypair.secretKey);
+        }
         return new RawSender_1.RawSender(wallet, keypair.secretKey);
     }
 }

package/dist/sender/TonConnectSender.d.ts

@@ -1,12 +1,12 @@
 import { TonConnectUI } from '@tonconnect/ui';
-import type { ShardTransaction } from '../structs/InternalStruct';
+import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
 import { ContractOpener, Network } from '../structs/Struct';
 import { SenderAbstraction } from './SenderAbstraction';
-import { SendTransactionResponse } from '@tonconnect/sdk';
 export declare class TonConnectSender implements SenderAbstraction {
     readonly tonConnect: TonConnectUI;
     constructor(tonConnect: TonConnectUI);
-    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendTransactionResponse[]>;
+    private sendChunkedMessages;
+    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain: Network, _contractOpener?: ContractOpener): Promise<SendResult[]>;
     getSenderAddress(): string;
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain: Network): Promise<SendTransactionResponse>;
+    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain: Network): Promise<SendResult>;
 }

package/dist/sender/TonConnectSender.js

@@ -5,13 +5,51 @@ const protocol_1 = require("@tonconnect/protocol");
 const ui_1 = require("@tonconnect/ui");
 const Struct_1 = require("../structs/Struct");
 const SenderAbstraction_1 = require("./SenderAbstraction");
+const CHUNK_SIZE = 4;
 class TonConnectSender {
     constructor(tonConnect) {
         this.tonConnect = tonConnect;
     }
-    async sendShardTransactions(shardTransactions, delay, chain, contractOpener) {
+    async sendChunkedMessages(messages, validUntil, chain) {
+        const responses = [];
+        let currentMessageIndex = 0;
+        const chunkSize = 
+        //@ts-ignore // 'find' checks that maxMessages is a property of the feature
+        this.tonConnect.wallet?.device.features.find((feat) => feat.hasOwnProperty('maxMessages'))?.maxMessages ||
+            CHUNK_SIZE;
+        for (let i = 0; i < messages.length; i += chunkSize) {
+            const chunk = messages.slice(i, i + chunkSize);
+            const transaction = {
+                validUntil,
+                messages: chunk,
+                network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
+            };
+            try {
+                const response = await this.tonConnect.sendTransaction(transaction);
+                responses.push({
+                    success: true,
+                    result: response,
+                    lastMessageIndex: currentMessageIndex + chunk.length - 1,
+                });
+                currentMessageIndex += chunk.length;
+            }
+            catch (error) {
+                responses.push({
+                    success: false,
+                    error: error,
+                    lastMessageIndex: currentMessageIndex - 1,
+                });
+                break; // Stop sending after first error
+            }
+            if (i + chunkSize < messages.length) {
+                await (0, SenderAbstraction_1.sleep)(1000);
+            }
+        }
+        return responses;
+    }
+    async sendShardTransactions(shardTransactions, delay, chain, _contractOpener) {
         const allMessages = [];
-        let minValidUntil = 0;
+        let minValidUntil = Number.MAX_SAFE_INTEGER;
         for (const transaction of shardTransactions) {
             for (const message of transaction.messages) {
                 allMessages.push({
@@ -22,14 +60,8 @@ class TonConnectSender {
             }
             minValidUntil = Math.min(minValidUntil, transaction.validUntil);
         }
-        const transaction = {
-            validUntil: minValidUntil,
-            messages: allMessages,
-            network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
-        };
         await (0, SenderAbstraction_1.sleep)(delay * 1000);
-        const response = await this.tonConnect.sendTransaction(transaction);
-        return [response];
+        return this.sendChunkedMessages(allMessages, minValidUntil, chain);
     }
     getSenderAddress() {
         return this.tonConnect.account?.address?.toString() || '';
@@ -43,13 +75,9 @@ class TonConnectSender {
                 payload: protocol_1.Base64.encode(message.payload.toBoc()).toString(),
             });
         }
-        const transaction = {
-            validUntil: shardTransaction.validUntil,
-            messages,
-            network: chain == Struct_1.Network.TESTNET ? ui_1.CHAIN.TESTNET : ui_1.CHAIN.MAINNET,
-        };
         await (0, SenderAbstraction_1.sleep)(delay * 1000);
-        return this.tonConnect.sendTransaction(transaction);
+        const responses = await this.sendChunkedMessages(messages, shardTransaction.validUntil, chain);
+        return responses[0];
     }
 }
 exports.TonConnectSender = TonConnectSender;

package/dist/sender/index.d.ts

@@ -1,2 +1,3 @@
 export * from './SenderAbstraction';
 export * from './SenderFactory';
+export * from './BatchSender';

package/dist/sender/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./SenderFactory"), exports);
+__exportStar(require("./BatchSender"), exports);

package/dist/structs/InternalStruct.d.ts

@@ -1,5 +1,5 @@
 import { Cell } from '@ton/ton';
-import { ContractOpener, TACSimulationResult, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, RawAssetBridgingData, StatusInfosByOperationId, OperationType, AssetType } from './Struct';
+import { ContractOpener, TACSimulationResult, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, RawAssetBridgingData, StatusInfosByOperationId, OperationType, AssetType, SuggestedTONExecutorFee } from './Struct';
 import { AbstractProvider, ethers, Interface, InterfaceAbi } from 'ethers';
 import { mainnet, testnet } from '@tonappchain/artifacts';
 export type ShardMessage = {
@@ -80,3 +80,10 @@ export type StatusesResponse = ResponseBase<StatusInfosByOperationId>;
 export type OperationIdsByShardsKeyResponse = ResponseBase<OperationIdsByShardsKey>;
 export type StageProfilingResponse = ResponseBase<ExecutionStagesByOperationId>;
 export type TACSimulationResponse = ResponseBase<TACSimulationResult>;
+export type SuggestedTONExecutorFeeResponse = ResponseBase<SuggestedTONExecutorFee>;
+export interface SendResult {
+    success: boolean;
+    result?: unknown;
+    error?: Error;
+    lastMessageIndex?: number;
+}