@tonappchain/sdk 0.7.2-scaled-ui-support-2 → 0.7.2

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

@@ -1,4 +1,4 @@
-import { Address, Cell } from '@ton/ton';
+import { Address, Cell, Message } from '@ton/ton';
 import { AbiCoder } from 'ethers';
 import type { FT, NFT, TON } from '../assets';
 import { Asset, IConfiguration } from '../interfaces';
@@ -37,3 +37,22 @@ export declare function getString(cell?: Cell): string;
  * Calculates (a * b + c / 2) / c with proper rounding
  */
 export declare function muldivr(a: bigint, b: bigint, c: bigint): bigint;
+/**
+ * Normalize hash string to base64 format
+ * Accepts: base64, hex, or raw string
+ */
+export declare function normalizeHashToBase64(hash: string): string;
+/**
+ * Normalize hash string to hex format
+ * Accepts: base64, hex
+ */
+export declare function normalizeHashToHex(hash: string): string;
+export declare function getNormalizedExtMessageHash(message: Message): string;
+export declare function retry<T>(fn: () => Promise<T>, options: {
+    retries: number;
+    delay: number;
+}): Promise<T>;
+export declare function recurisivelyCollectCellStats(cell: Cell): {
+    bits: number;
+    cells: number;
+};

package/dist/src/sdk/Utils.js

@@ -20,6 +20,11 @@ exports.getAddressString = getAddressString;
 exports.getNumber = getNumber;
 exports.getString = getString;
 exports.muldivr = muldivr;
+exports.normalizeHashToBase64 = normalizeHashToBase64;
+exports.normalizeHashToHex = normalizeHashToHex;
+exports.getNormalizedExtMessageHash = getNormalizedExtMessageHash;
+exports.retry = retry;
+exports.recurisivelyCollectCellStats = recurisivelyCollectCellStats;
 const ton_1 = require("@ton/ton");
 const ethers_1 = require("ethers");
 const ton_crypto_1 = require("ton-crypto");
@@ -47,6 +52,9 @@ function buildEvmDataCell(transactionLinker, evmProxyMsg, validExecutors) {
     const evmArguments = evmProxyMsg.encodedParameters
         ? Buffer.from(evmProxyMsg.encodedParameters.split('0x')[1], 'hex').toString('base64')
         : null;
+    if (!evmProxyMsg.methodName && evmArguments) {
+        throw (0, errors_1.invalidMethodNameError)(evmProxyMsg.methodName ?? '');
+    }
     const json = JSON.stringify({
         evmCall: {
             target: evmProxyMsg.evmTargetAddress,
@@ -143,13 +151,12 @@ const generateFeeData = (feeParams) => {
 };
 exports.generateFeeData = generateFeeData;
 async function waitUntilSuccess(options = {}, operation, operationDescription, ...args) {
-    const timeout = options.timeout ?? 300000;
-    const maxAttempts = options.maxAttempts ?? 30;
-    const delay = options.delay ?? 10000;
+    const timeout = options.timeout ?? Struct_1.defaultWaitOptions.timeout;
+    const maxAttempts = options.maxAttempts ?? Struct_1.defaultWaitOptions.maxAttempts;
+    const delay = options.delay ?? Struct_1.defaultWaitOptions.delay;
     const successCheck = options.successCheck;
     const context = options.context;
     const contextPrefix = operationDescription ? `[${operationDescription}] ` : '';
-    options.logger?.debug(`${contextPrefix}Starting wait for success with timeout=${timeout}ms, maxAttempts=${maxAttempts}, delay=${delay}ms`);
     const startTime = Date.now();
     let attempt = 1;
     while (true) {
@@ -160,12 +167,10 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
             if (result === undefined || result === null) {
                 throw new Error(`Empty result`);
             }
-            options.logger?.debug(`${contextPrefix}Result: ${formatObjectForLogging(result)}`);
             if (successCheck && !successCheck(result, context)) {
-                throw new Error(`Result is not successful`);
+                throw new Error(`Result is not successful: ${formatObjectForLogging(result)}`);
             }
-            options.logger?.debug(`${contextPrefix}Attempt ${attempt} successful`);
-            // Execute custom onSuccess callback if provided
+            options.logger?.debug(`${contextPrefix}Success (attempt ${attempt}/${maxAttempts})`);
             if (options.onSuccess) {
                 try {
                     await options.onSuccess(result, context);
@@ -185,8 +190,17 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
                 options.logger?.debug(`${contextPrefix}Max attempts (${maxAttempts}) reached`);
                 throw error;
             }
-            options.logger?.debug(`${contextPrefix}Error on attempt ${attempt}: ${error}`);
-            options.logger?.debug(`${contextPrefix}Waiting ${delay}ms before next attempt`);
+            const pendingMessage = statusRetryMessageFromError(error, attempt, maxAttempts, delay);
+            if (pendingMessage) {
+                options.logger?.debug(`${contextPrefix}${pendingMessage}`);
+            }
+            else {
+                let errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('<!doctype html>') || errorMessage.includes('<html')) {
+                    errorMessage = errorMessage.replace(/<!doctype html>[\s\S]*?<\/html>/gi, '[HTML response]');
+                }
+                options.logger?.debug(`${contextPrefix}attempt=${attempt}/${maxAttempts} failed; retry_in=${delay}ms; error=${errorMessage}`);
+            }
             await (0, exports.sleep)(delay);
             attempt++;
         }
@@ -195,6 +209,44 @@ async function waitUntilSuccess(options = {}, operation, operationDescription, .
 function formatObjectForLogging(obj) {
     return JSON.stringify(obj, (key, value) => (typeof value === 'bigint' ? value.toString() : value));
 }
+function statusRetryMessageFromError(error, attempt, maxAttempts, delay) {
+    const prefix = 'Result is not successful: ';
+    const message = String(error);
+    const index = message.indexOf(prefix);
+    if (index < 0) {
+        return null;
+    }
+    const payloadString = message.slice(index + prefix.length).trim();
+    let payload;
+    try {
+        payload = JSON.parse(payloadString);
+    }
+    catch {
+        return null;
+    }
+    if (typeof payload !== 'object' || payload === null) {
+        return null;
+    }
+    const statusPayload = payload;
+    if (statusPayload.stage === undefined &&
+        statusPayload.success === undefined &&
+        statusPayload.transactions === undefined) {
+        return null;
+    }
+    const stage = typeof statusPayload.stage === 'string' && statusPayload.stage ? statusPayload.stage : 'unknown';
+    const success = typeof statusPayload.success === 'boolean' ? String(statusPayload.success) : 'unknown';
+    let txHash = '-';
+    if (Array.isArray(statusPayload.transactions) && statusPayload.transactions.length > 0) {
+        const first = statusPayload.transactions[0];
+        if (typeof first === 'object' && first !== null && 'hash' in first) {
+            const maybeHash = first.hash;
+            if (typeof maybeHash === 'string' && maybeHash) {
+                txHash = maybeHash;
+            }
+        }
+    }
+    return `pending attempt=${attempt}/${maxAttempts} stage=${stage} success=${success} tx=${txHash} retry_in=${delay}ms`;
+}
 function getBouncedAddress(tvmAddress) {
     return ton_1.Address.parse(tvmAddress).toString({
         bounceable: true,
@@ -310,3 +362,99 @@ function muldivr(a, b, c) {
     }
     return (a * b + c / 2n) / c;
 }
+/**
+ * Normalize hash string to base64 format
+ * Accepts: base64, hex, or raw string
+ */
+function normalizeHashToBase64(hash) {
+    const input = hash.trim();
+    if (!input)
+        return input;
+    const hex = input.startsWith('0x') ? input.slice(2) : input;
+    if (/^[0-9a-fA-F]{64}$/.test(hex)) {
+        return Buffer.from(hex, 'hex').toString('base64');
+    }
+    const decoded = decodeBase64Like(input);
+    if (decoded) {
+        return decoded.toString('base64');
+    }
+    return input;
+}
+/**
+ * Normalize hash string to hex format
+ * Accepts: base64, hex
+ */
+function normalizeHashToHex(hash) {
+    const input = hash.trim();
+    if (!input)
+        return input;
+    const maybeHex = input.startsWith('0x') ? input.slice(2) : input;
+    if (/^[0-9a-fA-F]+$/.test(maybeHex) && maybeHex.length % 2 === 0) {
+        return maybeHex.toLowerCase();
+    }
+    const decoded = decodeBase64Like(input);
+    if (decoded) {
+        return decoded.toString('hex');
+    }
+    return input;
+}
+function decodeBase64Like(input) {
+    const normalized = input.replace(/-/g, '+').replace(/_/g, '/');
+    const padLength = normalized.length % 4;
+    const padded = padLength === 0 ? normalized : normalized + '='.repeat(4 - padLength);
+    if (!/^[A-Za-z0-9+/]+={0,2}$/.test(padded)) {
+        return null;
+    }
+    try {
+        const buf = Buffer.from(padded, 'base64');
+        return buf.length > 0 ? buf : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getNormalizedExtMessageHash(message) {
+    if (message.info.type !== 'external-in') {
+        throw new Error(`Message must be "external-in", got ${message.info.type}`);
+    }
+    const info = {
+        ...message.info,
+        src: undefined,
+        importFee: 0n,
+    };
+    const normalizedMessage = {
+        ...message,
+        init: null,
+        info: info,
+    };
+    return (0, ton_1.beginCell)()
+        .store((0, ton_1.storeMessage)(normalizedMessage, { forceRef: true }))
+        .endCell()
+        .hash()
+        .toString('base64');
+}
+async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                lastError = e;
+            }
+            await new Promise((resolve) => setTimeout(resolve, options.delay));
+        }
+    }
+    throw lastError;
+}
+function recurisivelyCollectCellStats(cell) {
+    let bits = cell.bits.length;
+    let cells = 1;
+    for (const ref of cell.refs) {
+        const stats = recurisivelyCollectCellStats(ref);
+        bits += stats.bits;
+        cells += stats.cells;
+    }
+    return { bits, cells };
+}

package/dist/src/sender/BatchSender.js

@@ -38,7 +38,16 @@ class BatchSender {
         for (const group of groups) {
             try {
                 const result = await this.sendGroup(group, contractOpener);
+                // Extract BoC if it's a string, or from sandbox result
+                let externalMsgBoc = '';
+                if (typeof result === 'string') {
+                    externalMsgBoc = result;
+                }
+                else if (result?.result) {
+                    externalMsgBoc = result.result;
+                }
                 results.push({
+                    boc: externalMsgBoc,
                     success: true,
                     result,
                     lastMessageIndex: currentMessageIndex + group.length - 1,
@@ -46,6 +55,7 @@ class BatchSender {
             }
             catch (error) {
                 results.push({
+                    boc: '',
                     success: false,
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
@@ -118,7 +128,16 @@ class BatchSender {
             }));
         }
         const result = await this.sendGroup(messages, contractOpener);
+        // Extract BoC if it's a string, or from sandbox result
+        let externalMsgBoc = '';
+        if (typeof result === 'string') {
+            externalMsgBoc = result;
+        }
+        else if (result?.result) {
+            externalMsgBoc = result.result;
+        }
         return {
+            boc: externalMsgBoc,
             success: true,
             result,
             lastMessageIndex: shardTransaction.messages.length - 1,

package/dist/src/sender/MockSender.d.ts

@@ -0,0 +1,2 @@
+import { SenderAbstraction } from '../interfaces';
+export declare const getMockSender: (senderAddress: string) => SenderAbstraction;

package/dist/src/sender/MockSender.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMockSender = void 0;
+const getMockSender = (senderAddress) => {
+    return {
+        getSenderAddress: () => senderAddress,
+        sendShardTransaction: async () => ({ success: true, boc: '' }),
+        sendShardTransactions: async () => [],
+        getBalance: async () => 0n,
+        getBalanceOf: async () => 0n,
+    };
+};
+exports.getMockSender = getMockSender;

package/dist/src/sender/RawSender.js

@@ -34,7 +34,16 @@ class RawSender {
         for (const batch of batches) {
             try {
                 const result = await this.sendBatch(batch, contractOpener);
+                // Extract BoC if it's a string, or from sandbox result
+                let externalMsgBoc = '';
+                if (typeof result === 'string') {
+                    externalMsgBoc = result;
+                }
+                else if (result?.result) {
+                    externalMsgBoc = result.result;
+                }
                 results.push({
+                    boc: externalMsgBoc,
                     success: true,
                     result,
                     lastMessageIndex: currentMessageIndex + batch.length - 1,
@@ -42,6 +51,7 @@ class RawSender {
             }
             catch (error) {
                 results.push({
+                    boc: '',
                     success: false,
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
@@ -63,12 +73,26 @@ class RawSender {
     async sendBatch(messages, contractOpener) {
         const walletContract = contractOpener.open(this.wallet);
         const seqno = await walletContract.getSeqno();
-        return walletContract.sendTransfer({
+        // Try to create BoC locally for standard wallets
+        const msg = this.wallet.createTransfer({
             seqno,
             secretKey: this.secretKey,
             messages,
             sendMode: ton_2.SendMode.PAY_GAS_SEPARATELY,
         });
+        let neededInit = null;
+        if (this.wallet.init && (await contractOpener.getContractState(this.wallet.address)).state !== 'active') {
+            neededInit = this.wallet.init;
+        }
+        const ext = (0, ton_1.external)({
+            to: this.wallet.address,
+            init: neededInit,
+            body: msg,
+        });
+        const boc = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(ext)).endCell().toBoc().toString('base64');
+        // Send the transaction
+        const result = await walletContract.send(msg);
+        return result || boc;
     }
     getSenderAddress() {
         return this.wallet.address.toString();
@@ -84,7 +108,16 @@ class RawSender {
             }));
         }
         const result = await this.sendBatch(messages, contractOpener);
+        // Extract BoC if it's a string, or from sandbox result
+        let externalMsgBoc = '';
+        if (typeof result === 'string') {
+            externalMsgBoc = result;
+        }
+        else if (result?.result) {
+            externalMsgBoc = result.result;
+        }
         return {
+            boc: externalMsgBoc,
             success: true,
             result,
             lastMessageIndex: shardTransaction.messages.length - 1,

package/dist/src/sender/SenderFactory.js

@@ -51,7 +51,7 @@ 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') {
+        if (wallet instanceof HighloadWalletV3_1.HighloadWalletV3) {
             return new BatchSender_1.BatchSender(wallet, keypair.secretKey);
         }
         return new RawSender_1.RawSender(wallet, keypair.secretKey, params.version === 'V5R1' ? 254 : 4);

package/dist/src/sender/TonConnectSender.js

@@ -35,6 +35,7 @@ class TonConnectSender {
                 responses.push({
                     success: true,
                     result: response,
+                    boc: response.boc,
                     lastMessageIndex: currentMessageIndex + chunk.length - 1,
                 });
                 currentMessageIndex += chunk.length;
@@ -42,6 +43,7 @@ class TonConnectSender {
             catch (error) {
                 responses.push({
                     success: false,
+                    boc: '',
                     error: error,
                     lastMessageIndex: currentMessageIndex - 1,
                 });

package/dist/src/sender/index.d.ts

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

package/dist/src/sender/index.js

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

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

@@ -1,4 +1,4 @@
-import { Cell } from '@ton/ton';
+import { Address, Cell } from '@ton/ton';
 import { AbstractProvider, ethers } from 'ethers';
 import { ICrossChainLayer, ISAFactory, ISettings, ITokenUtils } from '../../artifacts/tacTypes';
 import { ContractOpener } from '../interfaces';
@@ -7,6 +7,10 @@ export type ShardMessage = {
     address: string;
     value: bigint;
     payload: Cell;
+    extra: {
+        tonNetworkFee: bigint;
+        tacEstimatedGas?: bigint;
+    };
 };
 export type ShardTransaction = {
     validUntil: number;
@@ -32,6 +36,8 @@ export type InternalTONParams = {
     jettonWalletCode: Cell;
     nftItemCode: Cell;
     nftCollectionCode: Cell;
+    feesParams: TONFeesParams;
+    contractFeeUsageParams: ContractFeeUsageParams;
 };
 export type InternalTACParams = {
     provider: AbstractProvider;
@@ -61,6 +67,7 @@ export type OperationIdWithLogIndex = {
 export type OperationIdWithLogIndexResponse = ResponseBase<OperationIdWithLogIndex>;
 export interface SendResult {
     success: boolean;
+    boc: string;
     result?: unknown;
     error?: Error;
     lastMessageIndex?: number;
@@ -68,11 +75,11 @@ export interface SendResult {
 export type ToncenterTransaction = {
     description: {
         aborted: boolean;
-        action: {
+        action?: {
             resultCode: number;
             success: boolean;
         };
-        computePh: {
+        computePh?: {
             exitCode: number;
             success: boolean;
         };
@@ -82,21 +89,24 @@ export type ToncenterTransaction = {
     inMsg: {
         hash: string;
         opcode: string;
+        value: string;
     };
     outMsgs: {
         hash: string;
     }[];
 };
 export type TransactionDepth = {
+    address?: Address;
     hash: string;
     depth: number;
+    hashType?: 'unknown' | 'in' | 'out';
 };
 export type AdjacentTransactionsResponse = {
     transactions: ToncenterTransaction[];
 };
 export type TxFinalizerConfig = {
     urlBuilder: (hash: string) => string;
-    authorization: {
+    authorization?: {
         header: string;
         value: string;
     };
@@ -114,3 +124,87 @@ export type ConvertedCurrencyRawResult = {
     tacPrice: USDPriceInfoRaw;
     tonPrice: USDPriceInfoRaw;
 };
+export type TONFeesParams = {
+    accountBitPrice: number;
+    accountCellPrice: number;
+    lumpPrice: number;
+    gasPrice: number;
+    firstFrac: number;
+    ihrPriceFactor: number;
+    msgBitPrice: number;
+    msgCellPrice: number;
+};
+export type ContractFeeUsageParams = {
+    crossChainLayer: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            tvmMsgToEvm: number;
+        };
+    };
+    jettonWallet: {
+        accountBits: number;
+        accountCells: number;
+        estimatedAccountBits: number;
+        estimatedAccountCells: number;
+        initStateBits: number;
+        initStateCells: number;
+        gas: {
+            internalTransfer: number;
+            receive: number;
+            burn: number;
+            estimatedSendTransfer: number;
+            estimatedReceiveTransfer: number;
+        };
+    };
+    jettonProxy: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+            transferNotification: number;
+            errorNotification: number;
+        };
+    };
+    jettonMinter: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            burnNotification: number;
+            mintAfterError: number;
+        };
+    };
+    nftItem: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            send: number;
+            burn: number;
+            errorNotification: number;
+        };
+    };
+    nftProxy: {
+        accountBits: number;
+        accountCells: number;
+        gas: {
+            ownershipAssigned: number;
+            errorNotification: number;
+        };
+    };
+};
+export type TransactionFeeCalculationStep = {
+    accountBits: number;
+    accountCells: number;
+    gasUsed: number;
+    msgBits: number;
+    msgCells: number;
+    timeDelta: number;
+};
+export type TONFeeCalculationParams = TransactionFeeCalculationStep & TONFeesParams;
+export type TacGasPriceResponse = {
+    gasPrices: {
+        average: number;
+        fast: number;
+        slow: number;
+    };
+};