@dynamic-labs/ton 4.52.5 → 4.53.1

package/src/utils/getJettonWalletAddress/getJettonWalletAddress.d.ts

@@ -0,0 +1,17 @@
+import { TonClient } from '@ton/ton';
+export interface GetJettonWalletAddressParams {
+    /** Jetton master contract address */
+    jettonMasterAddress: string;
+    /** Owner's wallet address */
+    ownerAddress: string;
+    /** TonClient instance */
+    client: TonClient;
+}
+/**
+ * Derives a jetton wallet address for a given owner by calling
+ * the get_wallet_address method on the jetton master contract
+ *
+ * @param params - Parameters for getting jetton wallet address
+ * @returns Jetton wallet address for the owner
+ */
+export declare const getJettonWalletAddress: (params: GetJettonWalletAddressParams) => Promise<string>;

package/src/utils/getJettonWalletAddress/getJettonWalletAddress.js

@@ -0,0 +1,28 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Address, beginCell } from '@ton/ton';
+
+/**
+ * Derives a jetton wallet address for a given owner by calling
+ * the get_wallet_address method on the jetton master contract
+ *
+ * @param params - Parameters for getting jetton wallet address
+ * @returns Jetton wallet address for the owner
+ */
+const getJettonWalletAddress = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { jettonMasterAddress, ownerAddress, client } = params;
+    const masterAddress = Address.parse(jettonMasterAddress);
+    const owner = Address.parse(ownerAddress);
+    const ownerCell = beginCell().storeAddress(owner).endCell();
+    const result = yield client.runMethod(masterAddress, 'get_wallet_address', [
+        { cell: ownerCell, type: 'slice' },
+    ]);
+    const jettonWalletAddress = result.stack.readAddress();
+    return jettonWalletAddress.toString({
+        bounceable: true,
+        testOnly: false,
+        urlSafe: true,
+    });
+});
+
+export { getJettonWalletAddress };

package/src/utils/getJettonWalletAddress/index.d.ts

@@ -0,0 +1 @@
+export { getJettonWalletAddress, type GetJettonWalletAddressParams, } from './getJettonWalletAddress';

package/src/utils/getWalletSeqno/getWalletSeqno.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+
+/**
+ * Fetches the current seqno using TonClient
+ *
+ * @param walletAddress - Wallet address string
+ * @param client - TonClient instance
+ * @returns Current seqno
+ */
+const getWalletSeqno = (walletAddress, client) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const address = ton.Address.parse(walletAddress);
+    const result = yield client.runMethod(address, 'seqno');
+    return result.stack.readNumber();
+});
+
+exports.getWalletSeqno = getWalletSeqno;

package/src/utils/getWalletSeqno/getWalletSeqno.d.ts

@@ -0,0 +1,9 @@
+import { TonClient } from '@ton/ton';
+/**
+ * Fetches the current seqno using TonClient
+ *
+ * @param walletAddress - Wallet address string
+ * @param client - TonClient instance
+ * @returns Current seqno
+ */
+export declare const getWalletSeqno: (walletAddress: string, client: TonClient) => Promise<number>;

package/src/utils/getWalletSeqno/getWalletSeqno.js

@@ -0,0 +1,18 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Address } from '@ton/ton';
+
+/**
+ * Fetches the current seqno using TonClient
+ *
+ * @param walletAddress - Wallet address string
+ * @param client - TonClient instance
+ * @returns Current seqno
+ */
+const getWalletSeqno = (walletAddress, client) => __awaiter(void 0, void 0, void 0, function* () {
+    const address = Address.parse(walletAddress);
+    const result = yield client.runMethod(address, 'seqno');
+    return result.stack.readNumber();
+});
+
+export { getWalletSeqno };

package/src/utils/getWalletSeqno/index.d.ts

@@ -0,0 +1 @@
+export { getWalletSeqno } from './getWalletSeqno';

package/src/utils/index.d.ts

@@ -1 +1,13 @@
-export { TonUiTransaction, NANOTON_PER_TON, } from './TonUiTransaction/TonUiTransaction';
+export * from './TonUiTransaction';
+export * from './prepareTransaction';
+export * from './prepareTonTransfer';
+export * from './prepareJettonTransfer';
+export * from './getJettonWalletAddress';
+export * from './getWalletSeqno';
+export * from './executeTransaction';
+export * from './extractDisplayInfoFromRequest';
+export * from './convertSendTransactionRequest';
+export * from './generateTonConnectProofHash';
+export * from './logger/logger';
+export * from './isWalletDeployed/isWalletDeployed';
+export * from './createWalletStateInit/createWalletStateInit';

package/src/utils/isWalletDeployed/index.d.ts

@@ -0,0 +1 @@
+export * from './isWalletDeployed';

package/src/utils/isWalletDeployed/isWalletDeployed.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+
+/**
+ * Checks if a wallet contract is deployed on-chain by verifying if it has code.
+ *
+ * @param params - Parameters for checking wallet deployment
+ * @returns true if wallet contract is deployed (has code), false otherwise
+ */
+const isWalletDeployed = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, client } = params;
+    const address = ton.Address.parse(walletAddress);
+    const state = yield client.getContractState(address);
+    return state.state === 'active';
+});
+
+exports.isWalletDeployed = isWalletDeployed;

package/src/utils/isWalletDeployed/isWalletDeployed.d.ts

@@ -0,0 +1,14 @@
+import { TonClient } from '@ton/ton';
+export interface IsWalletDeployedParams {
+    /** Wallet address string */
+    walletAddress: string;
+    /** TonClient instance */
+    client: TonClient;
+}
+/**
+ * Checks if a wallet contract is deployed on-chain by verifying if it has code.
+ *
+ * @param params - Parameters for checking wallet deployment
+ * @returns true if wallet contract is deployed (has code), false otherwise
+ */
+export declare const isWalletDeployed: (params: IsWalletDeployedParams) => Promise<boolean>;

package/src/utils/isWalletDeployed/isWalletDeployed.js

@@ -0,0 +1,18 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Address } from '@ton/ton';
+
+/**
+ * Checks if a wallet contract is deployed on-chain by verifying if it has code.
+ *
+ * @param params - Parameters for checking wallet deployment
+ * @returns true if wallet contract is deployed (has code), false otherwise
+ */
+const isWalletDeployed = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, client } = params;
+    const address = Address.parse(walletAddress);
+    const state = yield client.getContractState(address);
+    return state.state === 'active';
+});
+
+export { isWalletDeployed };

package/src/utils/logger/logger.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('@dynamic-labs/ton');
+
+Object.defineProperty(exports, 'Logger', {
+	enumerable: true,
+	get: function () { return logger$1.Logger; }
+});
+exports.logger = logger;

package/src/utils/logger/logger.d.ts

@@ -0,0 +1,3 @@
+import { Logger, InstrumentOptions } from '@dynamic-labs/logger';
+export declare const logger: Logger;
+export { Logger, type InstrumentOptions };

package/src/utils/logger/logger.js

@@ -0,0 +1,7 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+export { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('@dynamic-labs/ton');
+
+export { logger };

package/src/utils/prepareJettonTransfer/index.d.ts

@@ -0,0 +1 @@
+export { prepareJettonTransfer, type PrepareJettonTransferParams, } from './prepareJettonTransfer';

package/src/utils/prepareJettonTransfer/prepareJettonTransfer.cjs

@@ -0,0 +1,78 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+var types = require('../../types.cjs');
+var getJettonWalletAddress = require('../getJettonWalletAddress/getJettonWalletAddress.cjs');
+
+const DEFAULT_JETTON_GAS = BigInt(50000000);
+/**
+ * Prepares a jetton (non-native token) transfer transaction
+ *
+ * @param params - Jetton transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+const prepareJettonTransfer = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, jettonMasterAddress, recipientAddress, jettonAmount, forwardTonAmount, client, forwardPayload = '', timeout = 60, gasAmount = DEFAULT_JETTON_GAS, network = types.CHAIN.MAINNET, } = params;
+    const validUntil = Math.floor(Date.now() / 1000) + timeout;
+    const jettonWalletAddress = yield getJettonWalletAddress.getJettonWalletAddress({
+        client,
+        jettonMasterAddress,
+        ownerAddress: walletAddress,
+    });
+    const jettonWalletAddr = ton.Address.parse(jettonWalletAddress);
+    const recipientAddr = ton.Address.parse(recipientAddress);
+    const walletAddr = ton.Address.parse(walletAddress);
+    const isTestnet = network === types.CHAIN.TESTNET;
+    // Build jetton transfer payload
+    // Jetton transfer message format (TEP-74):
+    // transfer#0f8a7ea5 query_id:uint64 amount:(VarUInteger 16)
+    //   destination:MsgAddress response_destination:MsgAddress
+    //   custom_payload:(Maybe ^Cell) forward_ton_amount:(VarUInteger 16)
+    //   forward_payload:(Either Cell ^Cell) = InternalMsgBody;
+    const forwardPayloadCell = forwardPayload
+        ? ton.beginCell()
+            .storeUint(0, 32) // text comment opcode
+            .storeStringTail(forwardPayload)
+            .endCell()
+        : ton.beginCell().endCell(); // empty cell
+    const jettonTransferBody = ton.beginCell()
+        .storeUint(0xf8a7ea5, 32) // jetton transfer op code
+        .storeUint(0, 64) // query_id (use 0 or timestamp)
+        .storeCoins(jettonAmount) // amount of jettons to transfer
+        .storeAddress(recipientAddr) // destination address
+        .storeAddress(walletAddr) // response_destination (excess TON goes here)
+        .storeBit(0) // custom_payload (null)
+        .storeCoins(forwardTonAmount) // forward_ton_amount
+        .storeBit(0) // forward_payload in this slice (not separate cell)
+        .storeSlice(forwardPayloadCell.beginParse()) // forward_payload content
+        .endCell();
+    // Total TON = forwardTonAmount + gas for the jetton transfer operation
+    const totalAmount = forwardTonAmount + gasAmount;
+    // Create TON Connect compatible message
+    const message = {
+        address: jettonWalletAddr.toString({
+            bounceable: true,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        amount: totalAmount.toString(),
+        payload: jettonTransferBody.toBoc().toString('base64'),
+    };
+    const request = {
+        from: walletAddr.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        messages: [message],
+        network,
+        validUntil,
+    };
+    return request;
+});
+
+exports.prepareJettonTransfer = prepareJettonTransfer;

package/src/utils/prepareJettonTransfer/prepareJettonTransfer.d.ts

@@ -0,0 +1,31 @@
+import { TonClient } from '@ton/ton';
+import { CHAIN, SendTransactionRequest } from '../../types';
+export interface PrepareJettonTransferParams {
+    /** Sender wallet address */
+    walletAddress: string;
+    /** Jetton master contract address */
+    jettonMasterAddress: string;
+    /** Recipient's main wallet address */
+    recipientAddress: string;
+    /** Amount of jettons in base units (bigint) */
+    jettonAmount: bigint;
+    /** TON amount to forward with notification */
+    forwardTonAmount: bigint;
+    /** TonClient instance */
+    client: TonClient;
+    /** Optional comment/memo */
+    forwardPayload?: string;
+    /** Network (MAINNET or TESTNET) */
+    network?: CHAIN;
+    /** Message timeout in seconds (default: 60) */
+    timeout?: number;
+    /** Gas amount in nanotons for the jetton transfer */
+    gasAmount?: bigint;
+}
+/**
+ * Prepares a jetton (non-native token) transfer transaction
+ *
+ * @param params - Jetton transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+export declare const prepareJettonTransfer: (params: PrepareJettonTransferParams) => Promise<SendTransactionRequest>;

package/src/utils/prepareJettonTransfer/prepareJettonTransfer.js

@@ -0,0 +1,74 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Address, beginCell } from '@ton/ton';
+import { CHAIN } from '../../types.js';
+import { getJettonWalletAddress } from '../getJettonWalletAddress/getJettonWalletAddress.js';
+
+const DEFAULT_JETTON_GAS = BigInt(50000000);
+/**
+ * Prepares a jetton (non-native token) transfer transaction
+ *
+ * @param params - Jetton transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+const prepareJettonTransfer = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, jettonMasterAddress, recipientAddress, jettonAmount, forwardTonAmount, client, forwardPayload = '', timeout = 60, gasAmount = DEFAULT_JETTON_GAS, network = CHAIN.MAINNET, } = params;
+    const validUntil = Math.floor(Date.now() / 1000) + timeout;
+    const jettonWalletAddress = yield getJettonWalletAddress({
+        client,
+        jettonMasterAddress,
+        ownerAddress: walletAddress,
+    });
+    const jettonWalletAddr = Address.parse(jettonWalletAddress);
+    const recipientAddr = Address.parse(recipientAddress);
+    const walletAddr = Address.parse(walletAddress);
+    const isTestnet = network === CHAIN.TESTNET;
+    // Build jetton transfer payload
+    // Jetton transfer message format (TEP-74):
+    // transfer#0f8a7ea5 query_id:uint64 amount:(VarUInteger 16)
+    //   destination:MsgAddress response_destination:MsgAddress
+    //   custom_payload:(Maybe ^Cell) forward_ton_amount:(VarUInteger 16)
+    //   forward_payload:(Either Cell ^Cell) = InternalMsgBody;
+    const forwardPayloadCell = forwardPayload
+        ? beginCell()
+            .storeUint(0, 32) // text comment opcode
+            .storeStringTail(forwardPayload)
+            .endCell()
+        : beginCell().endCell(); // empty cell
+    const jettonTransferBody = beginCell()
+        .storeUint(0xf8a7ea5, 32) // jetton transfer op code
+        .storeUint(0, 64) // query_id (use 0 or timestamp)
+        .storeCoins(jettonAmount) // amount of jettons to transfer
+        .storeAddress(recipientAddr) // destination address
+        .storeAddress(walletAddr) // response_destination (excess TON goes here)
+        .storeBit(0) // custom_payload (null)
+        .storeCoins(forwardTonAmount) // forward_ton_amount
+        .storeBit(0) // forward_payload in this slice (not separate cell)
+        .storeSlice(forwardPayloadCell.beginParse()) // forward_payload content
+        .endCell();
+    // Total TON = forwardTonAmount + gas for the jetton transfer operation
+    const totalAmount = forwardTonAmount + gasAmount;
+    // Create TON Connect compatible message
+    const message = {
+        address: jettonWalletAddr.toString({
+            bounceable: true,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        amount: totalAmount.toString(),
+        payload: jettonTransferBody.toBoc().toString('base64'),
+    };
+    const request = {
+        from: walletAddr.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        messages: [message],
+        network,
+        validUntil,
+    };
+    return request;
+});
+
+export { prepareJettonTransfer };

package/src/utils/prepareTonTransfer/index.d.ts

@@ -0,0 +1 @@
+export { prepareTonTransfer, type PrepareTonTransferParams, } from './prepareTonTransfer';

package/src/utils/prepareTonTransfer/prepareTonTransfer.cjs

@@ -0,0 +1,45 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+var types = require('../../types.cjs');
+
+/**
+ * Prepares a native TON transfer transaction
+ *
+ * @param params - Transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+const prepareTonTransfer = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, recipient, amount, timeout = 60, network = types.CHAIN.MAINNET, } = params;
+    const validUntil = Math.floor(Date.now() / 1000) + timeout;
+    const recipientAddress = ton.Address.parse(recipient);
+    const amountNano = ton.toNano(amount.toString());
+    const walletAddr = ton.Address.parse(walletAddress);
+    const isTestnet = network === types.CHAIN.TESTNET;
+    // Create TON Connect compatible message
+    const message = {
+        address: recipientAddress.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        amount: amountNano.toString(),
+    };
+    const request = {
+        from: walletAddr.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        messages: [message],
+        network,
+        validUntil,
+    };
+    return request;
+});
+
+exports.prepareTonTransfer = prepareTonTransfer;

package/src/utils/prepareTonTransfer/prepareTonTransfer.d.ts

@@ -0,0 +1,23 @@
+import { TonClient } from '@ton/ton';
+import { CHAIN, SendTransactionRequest } from '../../types';
+export interface PrepareTonTransferParams {
+    /** Sender wallet address */
+    walletAddress: string;
+    /** Recipient address */
+    recipient: string;
+    /** Amount in TON (will be converted to nanotons) */
+    amount: string | number;
+    /** TonClient instance */
+    client: TonClient;
+    /** Network (MAINNET or TESTNET, default: MAINNET) */
+    network?: CHAIN;
+    /** Message timeout in seconds (default: 60) */
+    timeout?: number;
+}
+/**
+ * Prepares a native TON transfer transaction
+ *
+ * @param params - Transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+export declare const prepareTonTransfer: (params: PrepareTonTransferParams) => Promise<SendTransactionRequest>;

package/src/utils/prepareTonTransfer/prepareTonTransfer.js

@@ -0,0 +1,41 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Address, toNano } from '@ton/ton';
+import { CHAIN } from '../../types.js';
+
+/**
+ * Prepares a native TON transfer transaction
+ *
+ * @param params - Transfer parameters
+ * @returns TON Connect SendTransactionRequest
+ */
+const prepareTonTransfer = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { walletAddress, recipient, amount, timeout = 60, network = CHAIN.MAINNET, } = params;
+    const validUntil = Math.floor(Date.now() / 1000) + timeout;
+    const recipientAddress = Address.parse(recipient);
+    const amountNano = toNano(amount.toString());
+    const walletAddr = Address.parse(walletAddress);
+    const isTestnet = network === CHAIN.TESTNET;
+    // Create TON Connect compatible message
+    const message = {
+        address: recipientAddress.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        amount: amountNano.toString(),
+    };
+    const request = {
+        from: walletAddr.toString({
+            bounceable: false,
+            testOnly: isTestnet,
+            urlSafe: true,
+        }),
+        messages: [message],
+        network,
+        validUntil,
+    };
+    return request;
+});
+
+export { prepareTonTransfer };

package/src/utils/prepareTransaction/index.d.ts

@@ -0,0 +1 @@
+export { prepareTransaction, type PrepareTransactionParams, type PrepareTransactionResult, } from './prepareTransaction';

package/src/utils/prepareTransaction/prepareTransaction.cjs

@@ -0,0 +1,74 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ton = require('@ton/ton');
+var core = require('@ton/core');
+var types = require('../../types.cjs');
+
+/**
+ * Prepares a v5r1 wallet transaction from an array of actions
+ *
+ * @param params - Parameters for preparing the transaction
+ * @returns The hash to sign and transaction data
+ */
+const prepareTransaction = (params) => {
+    const { actionsArray, walletAddress, seqno, validUntil, timeout, networkGlobalId = types.CHAIN.MAINNET, } = params;
+    const walletAddr = ton.Address.parse(walletAddress);
+    // Build actions cell from actions array
+    const actionsCell = ton.beginCell().store(core.storeOutList(actionsArray)).endCell();
+    const actions = ton.beginCell()
+        .storeBit(1) // storeMaybeRef - we have basic actions
+        .storeRef(actionsCell) // ref to basic actions
+        .storeBit(0) // no extended actions
+        .endCell();
+    // Calculate walletId following v5r1 spec:
+    // walletId = networkGlobalId XOR context
+    // context = (1 bit: isClient=1) + (8 bits: workchain) + (8 bits: version=0) + (15 bits: subwallet=0)
+    const context = ton.beginCell()
+        .storeUint(1, 1) // isClientContext
+        .storeInt(walletAddr.workChain, 8) // workchain
+        .storeUint(0, 8) // wallet_version (v5r1 = 0)
+        .storeUint(0, 15) // subwalletNumber
+        .endCell()
+        .beginParse()
+        .loadInt(32);
+    const walletIdValue = BigInt(networkGlobalId) ^ BigInt(context);
+    // Build the signing message according to v5r1 spec
+    // opcode | walletId | valid_until/timeout | seqno | actions
+    const signingMessage = ton.beginCell()
+        .storeUint(ton.WalletContractV5R1.OpCodes.auth_signed_external, 32)
+        .storeInt(walletIdValue, 32);
+    // For seqno 0 (first transaction/deployment), store 32 bits of 1s instead of validUntil
+    // This is a special case in v5r1 spec for the first transaction of a wallet
+    // It doesn't matter if the contract is already deployed or not.
+    if (seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(validUntil, 32);
+    }
+    signingMessage.storeUint(seqno, 32).storeSlice(actions.beginParse());
+    // Calculate hash to sign
+    const dataToSign = signingMessage.endCell();
+    const hashToSign = dataToSign.hash();
+    const hashToSignHex = hashToSign.toString('hex');
+    // Store the signing message
+    const messageBody = dataToSign.toBoc().toString('base64');
+    const transactionData = {
+        address: walletAddress,
+        messageBody,
+        seqno,
+        timeout,
+    };
+    return {
+        hashToSign,
+        hashToSignHex,
+        transactionData,
+    };
+};
+
+exports.prepareTransaction = prepareTransaction;

package/src/utils/prepareTransaction/prepareTransaction.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { OutActionSendMsg } from '@ton/core';
+import { CHAIN, type TonTransactionData } from '../../types';
+export interface PrepareTransactionParams {
+    /** Array of actions to include in the transaction */
+    actionsArray: OutActionSendMsg[];
+    /** Sender wallet address */
+    walletAddress: string;
+    /** Current wallet seqno */
+    seqno: number;
+    /** Unix timestamp when transaction expires */
+    validUntil: number;
+    /** Transaction timeout in seconds (for transactionData) */
+    timeout: number;
+    /** Network global ID (-239 for mainnet, -3 for testnet) */
+    networkGlobalId?: CHAIN;
+}
+export interface PrepareTransactionResult {
+    /** Hash to sign as Buffer */
+    hashToSign: Buffer;
+    /** Hash to sign as hex string */
+    hashToSignHex: string;
+    /** Transaction data for executeTransaction */
+    transactionData: TonTransactionData;
+}
+/**
+ * Prepares a v5r1 wallet transaction from an array of actions
+ *
+ * @param params - Parameters for preparing the transaction
+ * @returns The hash to sign and transaction data
+ */
+export declare const prepareTransaction: (params: PrepareTransactionParams) => PrepareTransactionResult;