@tonappchain/sdk 0.6.5-mainnet-alpha → 0.7.0-rc7

package/dist/sender/BatchSender.js

@@ -2,15 +2,23 @@
 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");
+const Consts_1 = require("../sdk/Consts");
+const HighloadWalletV3_1 = require("../wrappers/HighloadWalletV3");
 class BatchSender {
     constructor(wallet, secretKey) {
         this.wallet = wallet;
         this.secretKey = secretKey;
+        this.lastCreatedAt = 0;
+    }
+    async getBalanceOf(asset) {
+        return asset.getBalanceOf(this.getSenderAddress());
     }
-    async sendShardTransactions(shardTransactions, delay, _chain, contractOpener) {
+    async getBalance(contractOpener) {
+        const { balance } = await contractOpener.getContractState(this.wallet.address);
+        return balance;
+    }
+    async sendShardTransactions(shardTransactions, _chain, contractOpener) {
         const allMessages = [];
         let minValidUntil = Number.MAX_SAFE_INTEGER;
         for (const transaction of shardTransactions) {
@@ -28,7 +36,6 @@ class BatchSender {
         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({
@@ -85,16 +92,22 @@ class BatchSender {
     }
     async sendGroup(messages, contractOpener) {
         const walletContract = contractOpener.open(this.wallet);
+        let createdAt = HighloadWalletV3_1.HighloadWalletV3.generateCreatedAt();
+        if (createdAt <= this.lastCreatedAt) {
+            createdAt = this.lastCreatedAt + 1; // to prevent error::already_executed on highload wallet
+        }
+        this.lastCreatedAt = createdAt;
         return walletContract.sendTransfer({
             secretKey: this.secretKey,
             messages,
             sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            createdAt,
         });
     }
     getSenderAddress() {
         return this.wallet.address.toString();
     }
-    async sendShardTransaction(shardTransaction, delay, _chain, contractOpener) {
+    async sendShardTransaction(shardTransaction, _chain, contractOpener) {
         const messages = [];
         for (const message of shardTransaction.messages) {
             messages.push((0, ton_1.internal)({
@@ -104,7 +117,6 @@ class BatchSender {
                 body: message.payload,
             }));
         }
-        await (0, SenderAbstraction_1.sleep)(delay * 1000);
         const result = await this.sendGroup(messages, contractOpener);
         return {
             success: true,

package/dist/sender/RawSender.d.ts

@@ -1,12 +1,17 @@
-import type { ContractOpener } from '../structs/Struct';
 import type { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from '../structs/Struct';
 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<SendResult[]>;
+    private maxBatchSize;
+    constructor(wallet: WalletInstance, secretKey: Buffer, maxBatchSize?: number);
+    getBalanceOf(asset: Asset): Promise<bigint>;
+    getBalance(contractOpener: ContractOpener): Promise<bigint>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], _chain: Network, contractOpener: ContractOpener): Promise<SendResult[]>;
+    private prepareBatches;
+    private sendBatch;
     getSenderAddress(): string;
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, _chain: Network, contractOpener: ContractOpener): Promise<SendResult>;
+    sendShardTransaction(shardTransaction: ShardTransaction, _chain: Network, contractOpener: ContractOpener): Promise<SendResult>;
 }

package/dist/sender/RawSender.js

@@ -3,24 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RawSender = void 0;
 const ton_1 = require("@ton/ton");
 const ton_2 = require("@ton/ton");
-const SenderAbstraction_1 = require("./SenderAbstraction");
 class RawSender {
-    constructor(wallet, secretKey) {
+    constructor(wallet, secretKey, maxBatchSize = 4) {
         this.wallet = wallet;
         this.secretKey = secretKey;
+        this.maxBatchSize = maxBatchSize;
     }
-    async sendShardTransactions(shardTransactions, delay, chain, contractOpener) {
+    async getBalanceOf(asset) {
+        return asset.getBalanceOf(this.getSenderAddress());
+    }
+    async getBalance(contractOpener) {
+        const { balance } = await contractOpener.getContractState(this.wallet.address);
+        return balance;
+    }
+    async sendShardTransactions(shardTransactions, _chain, contractOpener) {
+        const allMessages = [];
+        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,
+                }));
+            }
+        }
+        const batches = this.prepareBatches(allMessages);
         const results = [];
         let currentMessageIndex = 0;
-        for (const shardTx of shardTransactions) {
+        for (const batch of batches) {
             try {
-                const result = await this.sendShardTransaction(shardTx, delay, chain, contractOpener);
+                const result = await this.sendBatch(batch, contractOpener);
                 results.push({
                     success: true,
                     result,
-                    lastMessageIndex: currentMessageIndex + shardTx.messages.length - 1,
+                    lastMessageIndex: currentMessageIndex + batch.length - 1,
                 });
-                currentMessageIndex += shardTx.messages.length;
             }
             catch (error) {
                 results.push({
@@ -30,16 +48,32 @@ class RawSender {
                 });
                 break; // Stop sending after first error
             }
+            currentMessageIndex += batch.length;
         }
         return results;
     }
-    getSenderAddress() {
-        return this.wallet.address.toString();
+    prepareBatches(messages) {
+        const batches = [];
+        for (let i = 0; i < messages.length; i += this.maxBatchSize) {
+            const batch = messages.slice(i, i + this.maxBatchSize);
+            batches.push(batch);
+        }
+        return batches;
     }
-    async sendShardTransaction(shardTransaction, delay, _chain, contractOpener) {
+    async sendBatch(messages, contractOpener) {
         const walletContract = contractOpener.open(this.wallet);
-        await (0, SenderAbstraction_1.sleep)(delay * 1000);
         const seqno = await walletContract.getSeqno();
+        return walletContract.sendTransfer({
+            seqno,
+            secretKey: this.secretKey,
+            messages,
+            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
+        });
+    }
+    getSenderAddress() {
+        return this.wallet.address.toString();
+    }
+    async sendShardTransaction(shardTransaction, _chain, contractOpener) {
         const messages = [];
         for (const message of shardTransaction.messages) {
             messages.push((0, ton_1.internal)({
@@ -49,13 +83,7 @@ class RawSender {
                 body: message.payload,
             }));
         }
-        await (0, SenderAbstraction_1.sleep)(delay * 1000);
-        const result = await walletContract.sendTransfer({
-            seqno,
-            secretKey: this.secretKey,
-            messages,
-            sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
-        });
+        const result = await this.sendBatch(messages, contractOpener);
         return {
             success: true,
             result,

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 { SendResult, ShardTransaction } from '../structs/InternalStruct';
+import type { Asset, ContractOpener } from '../structs/Struct';
 import { Network } from '../structs/Struct';
 export declare const sleep: (ms: number) => Promise<unknown>;
 export interface WalletInstance extends Contract {
@@ -14,7 +14,9 @@ export interface WalletInstance extends Contract {
     }): Promise<void>;
 }
 export interface SenderAbstraction {
-    sendShardTransaction(shardTransaction: ShardTransaction, delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
-    sendShardTransactions(shardTransactions: ShardTransaction[], delay: number, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
+    sendShardTransaction(shardTransaction: ShardTransaction, chain?: Network, contractOpener?: ContractOpener): Promise<SendResult>;
+    sendShardTransactions(shardTransactions: ShardTransaction[], chain?: Network, contractOpener?: ContractOpener): Promise<SendResult[]>;
     getSenderAddress(): string;
+    getBalance(contractOpener: ContractOpener): Promise<bigint>;
+    getBalanceOf(asset: Asset): Promise<bigint>;
 }

package/dist/sender/SenderFactory.d.ts

@@ -1,8 +1,8 @@
 import { WalletContractV2R1, WalletContractV2R2, WalletContractV3R1, WalletContractV3R2, WalletContractV4, WalletContractV5R1 } from '@ton/ton';
 import { TonConnectUI } from '@tonconnect/ui';
-import { SenderAbstraction } from './SenderAbstraction';
 import { Network } from '../structs/Struct';
 import { HighloadWalletV3 } from '../wrappers/HighloadWalletV3';
+import { SenderAbstraction } from './SenderAbstraction';
 export type WalletVersion = 'V2R1' | 'V2R2' | 'V3R1' | 'V3R2' | 'V4' | 'V5R1' | 'HIGHLOAD_V3';
 export declare const wallets: {
     V2R1: typeof WalletContractV2R1;

package/dist/sender/SenderFactory.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderFactory = exports.wallets = void 0;
 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");
+const BatchSender_1 = require("./BatchSender");
+const RawSender_1 = require("./RawSender");
+const TonConnectSender_1 = require("./TonConnectSender");
 exports.wallets = {
     V2R1: ton_1.WalletContractV2R1,
     V2R2: ton_1.WalletContractV2R2,
@@ -27,6 +27,7 @@ class SenderFactory {
             throw (0, errors_1.unknownWalletError)(params.version);
         }
         const keypair = await (0, ton_crypto_1.mnemonicToWalletKey)(params.mnemonic.split(' '));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const config = {
             workchain: 0,
             publicKey: keypair.publicKey,
@@ -53,7 +54,7 @@ class SenderFactory {
         if (params.version === 'HIGHLOAD_V3') {
             return new BatchSender_1.BatchSender(wallet, keypair.secretKey);
         }
-        return new RawSender_1.RawSender(wallet, keypair.secretKey);
+        return new RawSender_1.RawSender(wallet, keypair.secretKey, params.version === 'V5R1' ? 254 : 4);
     }
 }
 exports.SenderFactory = SenderFactory;

package/dist/sender/TonConnectSender.d.ts

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

package/dist/sender/TonConnectSender.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonConnectSender = void 0;
+const ton_1 = require("@ton/ton");
 const protocol_1 = require("@tonconnect/protocol");
 const ui_1 = require("@tonconnect/ui");
 const Struct_1 = require("../structs/Struct");
@@ -10,13 +11,18 @@ class TonConnectSender {
     constructor(tonConnect) {
         this.tonConnect = tonConnect;
     }
+    async getBalanceOf(asset) {
+        return asset.getBalanceOf(this.getSenderAddress());
+    }
+    async getBalance(contractOpener) {
+        return this.tonConnect.account
+            ? (await contractOpener.getContractState((0, ton_1.address)(this.tonConnect.account?.address))).balance
+            : 0n;
+    }
     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;
+        const chunkSize = this.tonConnect.wallet?.device.features.find((feat) => Object.prototype.hasOwnProperty.call(feat, 'maxMessages'))?.maxMessages || CHUNK_SIZE;
         for (let i = 0; i < messages.length; i += chunkSize) {
             const chunk = messages.slice(i, i + chunkSize);
             const transaction = {
@@ -47,7 +53,7 @@ class TonConnectSender {
         }
         return responses;
     }
-    async sendShardTransactions(shardTransactions, delay, chain, _contractOpener) {
+    async sendShardTransactions(shardTransactions, chain) {
         const allMessages = [];
         let minValidUntil = Number.MAX_SAFE_INTEGER;
         for (const transaction of shardTransactions) {
@@ -60,13 +66,12 @@ class TonConnectSender {
             }
             minValidUntil = Math.min(minValidUntil, transaction.validUntil);
         }
-        await (0, SenderAbstraction_1.sleep)(delay * 1000);
         return this.sendChunkedMessages(allMessages, minValidUntil, chain);
     }
     getSenderAddress() {
         return this.tonConnect.account?.address?.toString() || '';
     }
-    async sendShardTransaction(shardTransaction, delay, chain) {
+    async sendShardTransaction(shardTransaction, chain) {
         const messages = [];
         for (const message of shardTransaction.messages) {
             messages.push({
@@ -75,7 +80,6 @@ class TonConnectSender {
                 payload: protocol_1.Base64.encode(message.payload.toBoc()).toString(),
             });
         }
-        await (0, SenderAbstraction_1.sleep)(delay * 1000);
         const responses = await this.sendChunkedMessages(messages, shardTransaction.validUntil, chain);
         return responses[0];
     }

package/dist/sender/index.d.ts

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

package/dist/sender/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BatchSender"), exports);
 __exportStar(require("./SenderAbstraction"), exports);
 __exportStar(require("./SenderFactory"), exports);
-__exportStar(require("./BatchSender"), exports);

package/dist/structs/InternalStruct.d.ts

@@ -1,7 +1,7 @@
 import { Cell } from '@ton/ton';
-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';
+import { AbstractProvider, ethers } from 'ethers';
+import { ContractOpener, ExecutionStagesByOperationId, Network, OperationIdsByShardsKey, OperationType, StatusInfosByOperationId, SuggestedTONExecutorFee, TACSimulationResult } from './Struct';
 export type ShardMessage = {
     address: string;
     value: bigint;
@@ -22,31 +22,6 @@ export type RandomNumberByTimestamp = {
     timestamp: number;
     randomNumber: number;
 };
-export type JettonBridgingData = RawAssetBridgingData & {
-    type: AssetType.FT;
-    address: string;
-};
-export type JettonTransferData = JettonBridgingData;
-export type JettonBurnData = JettonBridgingData & {
-    notificationReceiverAddress: string;
-};
-export type NFTBridgingData = RawAssetBridgingData & {
-    type: AssetType.NFT;
-    address: string;
-};
-export type NFTTransferData = NFTBridgingData & {
-    to: string;
-    responseAddress: string;
-    evmData: Cell;
-    crossChainTonAmount?: bigint;
-    feeData?: Cell;
-};
-export type NFTBurnData = NFTBridgingData & {
-    notificationReceiverAddress: string;
-    evmData: Cell;
-    crossChainTonAmount?: bigint;
-    feeData?: Cell;
-};
 export type InternalTONParams = {
     contractOpener: ContractOpener;
     jettonProxyAddress: string;
@@ -60,16 +35,11 @@ export type InternalTONParams = {
 export type InternalTACParams = {
     provider: AbstractProvider;
     crossChainLayer: testnet.tac.wrappers.CrossChainLayerTAC | mainnet.tac.wrappers.CrossChainLayerTAC;
-    settings: testnet.tac.wrappers.SettingsTAC | testnet.tac.wrappers.SettingsTAC;
+    settings: testnet.tac.wrappers.SettingsTAC | mainnet.tac.wrappers.SettingsTAC;
     tokenUtils: testnet.tac.wrappers.TokenUtilsTAC | mainnet.tac.wrappers.TokenUtilsTAC;
     trustedTACExecutors: string[];
     trustedTONExecutors: string[];
     abiCoder: ethers.AbiCoder;
-    crossChainLayerABI: Interface | InterfaceAbi;
-    crossChainLayerTokenABI: Interface | InterfaceAbi;
-    crossChainLayerTokenBytecode: string;
-    crossChainLayerNFTABI: Interface | InterfaceAbi;
-    crossChainLayerNFTBytecode: string;
 };
 export type ResponseBase<T> = {
     response: T;
@@ -87,3 +57,36 @@ export interface SendResult {
     error?: Error;
     lastMessageIndex?: number;
 }
+export type ToncenterTransaction = {
+    description: {
+        aborted: boolean;
+        action: {
+            resultCode: number;
+            success: boolean;
+        };
+        computePh: {
+            exitCode: number;
+            success: boolean;
+        };
+        destroyed: boolean;
+    };
+    hash: string;
+    inMsg: {
+        hash: string;
+        opcode: string;
+    };
+};
+export type TransactionDepth = {
+    hash: string;
+    depth: number;
+};
+export type AdjacentTransactionsResponse = {
+    transactions: ToncenterTransaction[];
+};
+export type TxFinalizerConfig = {
+    urlBuilder: (hash: string) => string;
+    authorization: {
+        header: string;
+        value: string;
+    };
+};

package/dist/structs/Services.d.ts

@@ -0,0 +1,40 @@
+import { mainnet, testnet } from '@tonappchain/artifacts';
+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';
+export interface IConfiguration {
+    readonly network: Network;
+    readonly artifacts: typeof testnet | typeof mainnet;
+    readonly TONParams: InternalTONParams;
+    readonly TACParams: InternalTACParams;
+    readonly liteSequencerEndpoints: string[];
+    readonly nativeTONAddress: string;
+    nativeTACAddress(): Promise<string>;
+    readonly getTrustedTACExecutors: string[];
+    readonly getTrustedTONExecutors: string[];
+    closeConnections(): unknown;
+    isContractDeployedOnTVM(address: string): Promise<boolean>;
+}
+export interface ILogger {
+    debug(...arg: unknown[]): void;
+    info(...arg: unknown[]): void;
+    warn(...arg: unknown[]): void;
+    error(...arg: unknown[]): void;
+}
+export interface ISimulator {
+    simulateTACMessage(req: TACSimulationRequest): Promise<TACSimulationResult>;
+    simulateTransactions(sender: SenderAbstraction, txs: CrosschainTx[]): Promise<TACSimulationResult[]>;
+    getTVMExecutorFeeInfo(assets: Asset[], feeSymbol: string): Promise<SuggestedTONExecutorFee>;
+    getTransactionSimulationInfo(evmProxyMsg: EvmProxyMsg, sender: SenderAbstraction, assets?: Asset[]): Promise<ExecutionFeeEstimationResult>;
+    getSimulationInfoForTransaction(evmProxyMsg: EvmProxyMsg, transactionLinker: TransactionLinker, assets: Asset[], allowSimulationError?: boolean, isRoundTrip?: boolean, evmValidExecutors?: string[], tvmValidExecutors?: string[]): Promise<ExecutionFeeEstimationResult>;
+}
+export interface IOperationTracker {
+    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>;
+    getStageProfiling(operationId: string, waitOptions?: WaitOptions<ExecutionStages>): Promise<ExecutionStages>;
+    getStageProfilings(operationIds: string[], waitOptions?: WaitOptions<ExecutionStagesByOperationId>, chunkSize?: number): Promise<ExecutionStagesByOperationId>;
+    getOperationStatuses(operationIds: string[], waitOptions?: WaitOptions<StatusInfosByOperationId>, chunkSize?: number): Promise<StatusInfosByOperationId>;
+    getOperationStatus(operationId: string, waitOptions?: WaitOptions<StatusInfo>): Promise<StatusInfo>;
+    getSimplifiedOperationStatus(transactionLinker: TransactionLinker): Promise<SimplifiedStatuses>;
+}

package/dist/structs/Services.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });