@dynamic-labs/waas-ton 4.51.2 → 4.52.0

package/src/utils/generateTonConnectProofHash/generateTonConnectProofHash.js

@@ -0,0 +1,85 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { sha256 } from '@ton/crypto';
+import { Address } from '@ton/ton';
+
+const TON_PROOF_PREFIX = 'ton-proof-item-v2/';
+const TON_CONNECT_PREFIX = 'ton-connect';
+/**
+ * Builds the TON Connect message
+ *
+ * According to TON Connect spec:
+ * message = utf8_encode("ton-proof-item-v2/") ++
+ *           Address ++
+ *           AppDomain ++
+ *           Timestamp ++
+ *           Payload
+ *
+ * Where:
+ * - Address = workchain (32-bit big-endian) + hash (256-bit)
+ * - AppDomain = lengthBytes (32-bit little-endian) + domain value (bytes)
+ * - Timestamp = 64-bit little-endian
+ * - Payload = payload string (bytes)
+ */
+const generateTonConnectProofMessage = (params) => {
+    const address = Address.parse(params.address);
+    // Validate that lengthBytes matches the actual byte length of domain value
+    const domainBytes = Buffer.from(params.domain.value);
+    const actualLengthBytes = domainBytes.length;
+    if (params.domain.lengthBytes !== actualLengthBytes) {
+        throw new Error(`Domain lengthBytes mismatch: provided ${params.domain.lengthBytes}, actual ${actualLengthBytes}`);
+    }
+    // Workchain (32-bit big-endian)
+    const wc = Buffer.alloc(4);
+    wc.writeUInt32BE(address.workChain, 0);
+    // Timestamp (64-bit little-endian)
+    const ts = Buffer.alloc(8);
+    ts.writeBigUInt64LE(BigInt(params.timestamp), 0);
+    // Domain length (32-bit little-endian)
+    const dl = Buffer.alloc(4);
+    dl.writeUInt32LE(params.domain.lengthBytes, 0);
+    // Concatenate all parts
+    return Buffer.concat([
+        Buffer.from(TON_PROOF_PREFIX),
+        wc,
+        address.hash,
+        dl,
+        domainBytes,
+        ts,
+        Buffer.from(params.payload),
+    ]);
+};
+/**
+ * Generates the hash that needs to be signed by the private key for TON Connect proof
+ *
+ * The signature process:
+ * 1. Build the message: ton-proof-item-v2/ + Address + AppDomain + Timestamp + Payload
+ * 2. Hash the message: sha256(message)
+ * 3. Build full message: 0xffff + "ton-connect" + sha256(message)
+ * 4. Hash again: sha256(full message) - This is what needs to be signed
+ *
+ * @param params - Parameters for generating the TON Connect proof hash
+ * @returns The hash as hex string that needs to be signed
+ */
+const generateTonConnectProofHash = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    // 1. Build the message
+    const message = generateTonConnectProofMessage({
+        address: params.address,
+        domain: params.domain,
+        payload: params.payload,
+        timestamp: params.timestamp,
+    });
+    // 2. Hash the message
+    const messageHash = Buffer.from((yield sha256(message)));
+    // 3. Build the full message for signing
+    const fullMsg = Buffer.concat([
+        Buffer.from([0xff, 0xff]),
+        Buffer.from(TON_CONNECT_PREFIX),
+        messageHash,
+    ]);
+    // Step 4: Hash again
+    const hash = Buffer.from((yield sha256(fullMsg)));
+    return hash.toString('hex');
+});
+
+export { generateTonConnectProofHash };

package/src/utils/getJettonWalletAddress/getJettonWalletAddress.cjs

@@ -0,0 +1,32 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@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) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { jettonMasterAddress, ownerAddress, client } = params;
+    const masterAddress = ton.Address.parse(jettonMasterAddress);
+    const owner = ton.Address.parse(ownerAddress);
+    const ownerCell = ton.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,
+    });
+});
+
+exports.getJettonWalletAddress = getJettonWalletAddress;

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/index.d.ts

@@ -1,2 +1,10 @@
+export * from './prepareTransaction/prepareTransaction';
+export * from './generateTonConnectProofHash/generateTonConnectProofHash';
+export * from './prepareTonTransfer/prepareTonTransfer';
+export * from './prepareJettonTransfer/prepareJettonTransfer';
+export * from './getJettonWalletAddress/getJettonWalletAddress';
 export * from './getWalletSeqno/getWalletSeqno';
+export * from './executeTransaction/executeTransaction';
+export * from './extractDisplayInfoFromRequest/extractDisplayInfoFromRequest';
+export * from './convertSendTransactionRequest/convertSendTransactionRequest';
 export * from './logger/logger';

package/src/utils/logger/logger.cjs

@@ -3,11 +3,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var logger = require('@dynamic-labs/logger');
+var logger$1 = require('@dynamic-labs/logger');
 
-new logger.Logger('@dynamic-labs/waas-ton');
+const logger = new logger$1.Logger('@dynamic-labs/waas-ton');
 
 Object.defineProperty(exports, 'Logger', {
 	enumerable: true,
-	get: function () { return logger.Logger; }
+	get: function () { return logger$1.Logger; }
 });
+exports.logger = logger;

package/src/utils/logger/logger.js

@@ -2,4 +2,6 @@
 import { Logger } from '@dynamic-labs/logger';
 export { Logger } from '@dynamic-labs/logger';
 
-new Logger('@dynamic-labs/waas-ton');
+const logger = new Logger('@dynamic-labs/waas-ton');
+
+export { logger };

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 index = require('../../types/index.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 = index.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 === index.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/index.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/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 index = require('../../types/index.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 = index.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 === index.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/index.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/prepareTransaction.cjs

@@ -0,0 +1,65 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ton = require('@ton/ton');
+var core = require('@ton/core');
+var index = require('../../types/index.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 = index.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)
+        .storeUint(validUntil, 32)
+        .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;

package/src/utils/prepareTransaction/prepareTransaction.js

@@ -0,0 +1,61 @@
+'use client'
+import { Address, beginCell, WalletContractV5R1 } from '@ton/ton';
+import { storeOutList } from '@ton/core';
+import { CHAIN } from '../../types/index.js';
+
+/**
+ * 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 = CHAIN.MAINNET, } = params;
+    const walletAddr = Address.parse(walletAddress);
+    // Build actions cell from actions array
+    const actionsCell = beginCell().store(storeOutList(actionsArray)).endCell();
+    const actions = 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 = 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 = beginCell()
+        .storeUint(WalletContractV5R1.OpCodes.auth_signed_external, 32)
+        .storeInt(walletIdValue, 32)
+        .storeUint(validUntil, 32)
+        .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,
+    };
+};
+
+export { prepareTransaction };