@dynamic-labs/waas-ton 4.51.0 → 4.52.0

package/src/types/index.js

@@ -0,0 +1,11 @@
+'use client'
+/**
+ * Network chain identifier for TON
+ */
+var CHAIN;
+(function (CHAIN) {
+    CHAIN["MAINNET"] = "-239";
+    CHAIN["TESTNET"] = "-3";
+})(CHAIN || (CHAIN = {}));
+
+export { CHAIN };

package/src/utils/convertSendTransactionRequest/convertSendTransactionRequest.cjs

@@ -0,0 +1,117 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ton = require('@ton/ton');
+var core = require('@ton/core');
+
+/**
+ * Parses a base64 BOC payload into a Cell
+ *
+ * @param payload - Base64 encoded BOC string
+ * @returns Parsed Cell
+ */
+const parsePayload = (payload) => {
+    if (!payload) {
+        return ton.beginCell().endCell();
+    }
+    try {
+        return ton.Cell.fromBase64(payload);
+    }
+    catch (e) {
+        throw new Error(`Invalid payload BOC: ${e instanceof Error ? e.message : String(e)}`);
+    }
+};
+/**
+ * Parses a base64 BOC stateInit into code and data cells
+ *
+ * @param stateInit - Base64 encoded BOC string
+ * @returns Object with code and data cells, or undefined if no stateInit
+ */
+const parseStateInit = (stateInit) => {
+    if (!stateInit) {
+        return undefined;
+    }
+    try {
+        const stateInitCell = ton.Cell.fromBase64(stateInit);
+        const slice = stateInitCell.beginParse();
+        slice.skip(2); // skip split_depth and special flags
+        return {
+            code: slice.loadRef(),
+            data: slice.loadRef(),
+        };
+    }
+    catch (e) {
+        throw new Error(`Invalid stateInit BOC: ${e instanceof Error ? e.message : String(e)}`);
+    }
+};
+/**
+ * Determines the bounce flag from address format
+ *
+ * In base64 user-friendly format:
+ * - Bounceable addresses start with: EQ (mainnet) or kQ (testnet)
+ * - Non-bounceable addresses start with: UQ (mainnet) or 0Q (testnet)
+ * Default to true (bounceable) for safety with smart contracts
+ *
+ * @param address - TON address string
+ * @returns Boolean bounce flag
+ */
+// Non-bounceable addresses start with UQ (mainnet) or 0Q (testnet)
+// All other formats (EQ, kQ, raw) default to bounceable
+const determineBounceFlag = (address) => !address.startsWith('UQ') && !address.startsWith('0Q');
+/**
+ * Creates an internal message object
+ *
+ * @param destAddr - Destination address
+ * @param amount - Amount in nanotons
+ * @param body - Message body cell
+ * @param bounce - Bounce flag
+ * @param init - Optional state init with code and data
+ * @returns Internal message object
+ */
+const createInternalMessage = (destAddr, amount, body, bounce, init) => (Object.assign({ body, info: {
+        bounce,
+        bounced: false,
+        createdAt: 0,
+        createdLt: BigInt(0),
+        dest: destAddr,
+        forwardFee: BigInt(0),
+        ihrDisabled: true,
+        ihrFee: BigInt(0),
+        src: null,
+        type: 'internal',
+        value: { coins: amount },
+    } }, (init && { init })));
+/**
+ * Creates an OutActionSendMsg from an internal message
+ *
+ * @param internalMessage - The internal message object
+ * @returns OutActionSendMsg action
+ */
+const createSendMsgAction = (internalMessage) => ({
+    mode: core.SendMode.PAY_GAS_SEPARATELY | core.SendMode.IGNORE_ERRORS,
+    outMsg: internalMessage,
+    type: 'sendMsg',
+});
+/**
+ * Converts a TON Connect SendTransactionRequest to internal actions array
+ *
+ * @param request - TON Connect transaction request
+ * @returns Array of OutActionSendMsg actions
+ */
+const convertSendTransactionRequest = (request) => {
+    const actions = [];
+    for (const msg of request.messages) {
+        const destAddr = ton.Address.parse(msg.address);
+        const amount = BigInt(msg.amount);
+        const body = parsePayload(msg.payload);
+        const init = parseStateInit(msg.stateInit);
+        const bounce = determineBounceFlag(msg.address);
+        const internalMessage = createInternalMessage(destAddr, amount, body, bounce, init);
+        actions.push(createSendMsgAction(internalMessage));
+    }
+    return actions;
+};
+
+exports.convertSendTransactionRequest = convertSendTransactionRequest;

package/src/utils/convertSendTransactionRequest/convertSendTransactionRequest.d.ts

@@ -0,0 +1,9 @@
+import { OutActionSendMsg } from '@ton/core';
+import { SendTransactionRequest } from '../../types';
+/**
+ * Converts a TON Connect SendTransactionRequest to internal actions array
+ *
+ * @param request - TON Connect transaction request
+ * @returns Array of OutActionSendMsg actions
+ */
+export declare const convertSendTransactionRequest: (request: SendTransactionRequest) => OutActionSendMsg[];

package/src/utils/convertSendTransactionRequest/convertSendTransactionRequest.js

@@ -0,0 +1,113 @@
+'use client'
+import { Address, beginCell, Cell } from '@ton/ton';
+import { SendMode } from '@ton/core';
+
+/**
+ * Parses a base64 BOC payload into a Cell
+ *
+ * @param payload - Base64 encoded BOC string
+ * @returns Parsed Cell
+ */
+const parsePayload = (payload) => {
+    if (!payload) {
+        return beginCell().endCell();
+    }
+    try {
+        return Cell.fromBase64(payload);
+    }
+    catch (e) {
+        throw new Error(`Invalid payload BOC: ${e instanceof Error ? e.message : String(e)}`);
+    }
+};
+/**
+ * Parses a base64 BOC stateInit into code and data cells
+ *
+ * @param stateInit - Base64 encoded BOC string
+ * @returns Object with code and data cells, or undefined if no stateInit
+ */
+const parseStateInit = (stateInit) => {
+    if (!stateInit) {
+        return undefined;
+    }
+    try {
+        const stateInitCell = Cell.fromBase64(stateInit);
+        const slice = stateInitCell.beginParse();
+        slice.skip(2); // skip split_depth and special flags
+        return {
+            code: slice.loadRef(),
+            data: slice.loadRef(),
+        };
+    }
+    catch (e) {
+        throw new Error(`Invalid stateInit BOC: ${e instanceof Error ? e.message : String(e)}`);
+    }
+};
+/**
+ * Determines the bounce flag from address format
+ *
+ * In base64 user-friendly format:
+ * - Bounceable addresses start with: EQ (mainnet) or kQ (testnet)
+ * - Non-bounceable addresses start with: UQ (mainnet) or 0Q (testnet)
+ * Default to true (bounceable) for safety with smart contracts
+ *
+ * @param address - TON address string
+ * @returns Boolean bounce flag
+ */
+// Non-bounceable addresses start with UQ (mainnet) or 0Q (testnet)
+// All other formats (EQ, kQ, raw) default to bounceable
+const determineBounceFlag = (address) => !address.startsWith('UQ') && !address.startsWith('0Q');
+/**
+ * Creates an internal message object
+ *
+ * @param destAddr - Destination address
+ * @param amount - Amount in nanotons
+ * @param body - Message body cell
+ * @param bounce - Bounce flag
+ * @param init - Optional state init with code and data
+ * @returns Internal message object
+ */
+const createInternalMessage = (destAddr, amount, body, bounce, init) => (Object.assign({ body, info: {
+        bounce,
+        bounced: false,
+        createdAt: 0,
+        createdLt: BigInt(0),
+        dest: destAddr,
+        forwardFee: BigInt(0),
+        ihrDisabled: true,
+        ihrFee: BigInt(0),
+        src: null,
+        type: 'internal',
+        value: { coins: amount },
+    } }, (init && { init })));
+/**
+ * Creates an OutActionSendMsg from an internal message
+ *
+ * @param internalMessage - The internal message object
+ * @returns OutActionSendMsg action
+ */
+const createSendMsgAction = (internalMessage) => ({
+    mode: SendMode.PAY_GAS_SEPARATELY | SendMode.IGNORE_ERRORS,
+    outMsg: internalMessage,
+    type: 'sendMsg',
+});
+/**
+ * Converts a TON Connect SendTransactionRequest to internal actions array
+ *
+ * @param request - TON Connect transaction request
+ * @returns Array of OutActionSendMsg actions
+ */
+const convertSendTransactionRequest = (request) => {
+    const actions = [];
+    for (const msg of request.messages) {
+        const destAddr = Address.parse(msg.address);
+        const amount = BigInt(msg.amount);
+        const body = parsePayload(msg.payload);
+        const init = parseStateInit(msg.stateInit);
+        const bounce = determineBounceFlag(msg.address);
+        const internalMessage = createInternalMessage(destAddr, amount, body, bounce, init);
+        actions.push(createSendMsgAction(internalMessage));
+    }
+    return actions;
+};
+
+export { convertSendTransactionRequest };

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

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

package/src/utils/executeTransaction/executeTransaction.cjs

@@ -0,0 +1,55 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var ton = require('@ton/ton');
+var core = require('@ton/core');
+
+/**
+ * Executes a TON transaction
+ *
+ * @param params - Parameters for executing the transaction
+ * @returns Transaction execution result with hash
+ */
+const executeTransaction = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const signatureBuffer = Buffer.from(params.signature, 'base64');
+        if (signatureBuffer.length !== 64) {
+            throw new Error(`Invalid signature length: expected 64 bytes, got ${signatureBuffer.length}`);
+        }
+        // Parse the signing message (without signature)
+        const signingMessageCell = ton.Cell.fromBase64(params.transactionData.messageBody);
+        // Append signature to tail (v5r1 uses packSignatureToTail)
+        const signedMessageBody = ton.beginCell()
+            .storeSlice(signingMessageCell.beginParse())
+            .storeBuffer(signatureBuffer) // Signature at tail
+            .endCell();
+        const address = ton.Address.parse(params.transactionData.address);
+        // Build external message
+        const externalMsg = core.external({
+            body: signedMessageBody,
+            to: address,
+        });
+        // Use storeMessage to properly serialize
+        const externalMessage = ton.beginCell()
+            .store(core.storeMessage(externalMsg, { forceRef: true }))
+            .endCell();
+        const boc = externalMessage.toBoc();
+        yield params.client.sendFile(boc);
+        const txHash = externalMessage.hash().toString('hex');
+        return {
+            success: true,
+            transactionHash: txHash,
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            success: false,
+        };
+    }
+});
+
+exports.executeTransaction = executeTransaction;

package/src/utils/executeTransaction/executeTransaction.d.ts

@@ -0,0 +1,25 @@
+import { TonClient } from '@ton/ton';
+import type { TonTransactionData } from '../../types';
+export interface ExecuteTransactionParams {
+    /** Generic transaction data */
+    transactionData: TonTransactionData;
+    /** Signature as base64 */
+    signature: string;
+    /** TonClient instance */
+    client: TonClient;
+}
+export interface ExecuteTransactionResult {
+    /** Whether the transaction was sent successfully */
+    success: boolean;
+    /** Transaction hash (if successful) */
+    transactionHash?: string;
+    /** Error message (if failed) */
+    error?: string;
+}
+/**
+ * Executes a TON transaction
+ *
+ * @param params - Parameters for executing the transaction
+ * @returns Transaction execution result with hash
+ */
+export declare const executeTransaction: (params: ExecuteTransactionParams) => Promise<ExecuteTransactionResult>;

package/src/utils/executeTransaction/executeTransaction.js

@@ -0,0 +1,51 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Cell, beginCell, Address } from '@ton/ton';
+import { external, storeMessage } from '@ton/core';
+
+/**
+ * Executes a TON transaction
+ *
+ * @param params - Parameters for executing the transaction
+ * @returns Transaction execution result with hash
+ */
+const executeTransaction = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const signatureBuffer = Buffer.from(params.signature, 'base64');
+        if (signatureBuffer.length !== 64) {
+            throw new Error(`Invalid signature length: expected 64 bytes, got ${signatureBuffer.length}`);
+        }
+        // Parse the signing message (without signature)
+        const signingMessageCell = Cell.fromBase64(params.transactionData.messageBody);
+        // Append signature to tail (v5r1 uses packSignatureToTail)
+        const signedMessageBody = beginCell()
+            .storeSlice(signingMessageCell.beginParse())
+            .storeBuffer(signatureBuffer) // Signature at tail
+            .endCell();
+        const address = Address.parse(params.transactionData.address);
+        // Build external message
+        const externalMsg = external({
+            body: signedMessageBody,
+            to: address,
+        });
+        // Use storeMessage to properly serialize
+        const externalMessage = beginCell()
+            .store(storeMessage(externalMsg, { forceRef: true }))
+            .endCell();
+        const boc = externalMessage.toBoc();
+        yield params.client.sendFile(boc);
+        const txHash = externalMessage.hash().toString('hex');
+        return {
+            success: true,
+            transactionHash: txHash,
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            success: false,
+        };
+    }
+});
+
+export { executeTransaction };

package/src/utils/extractDisplayInfoFromRequest/extractDisplayInfoFromRequest.cjs

@@ -0,0 +1,51 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ton = require('@ton/ton');
+
+/**
+ * Extracts display information from a SendTransactionRequest
+ *
+ * @param request - TON Connect SendTransactionRequest
+ * @returns Display information for UI confirmation
+ */
+const extractDisplayInfoFromRequest = (request) => {
+    const [firstMessage] = request.messages;
+    const displayInfo = {
+        recipient: firstMessage.address,
+        value: firstMessage.amount,
+    };
+    // If there is no payload, return the default display info for a simple transfer
+    if (!firstMessage.payload) {
+        return displayInfo;
+    }
+    try {
+        const payloadCell = ton.Cell.fromBase64(firstMessage.payload);
+        const slice = payloadCell.beginParse();
+        const opCode = slice.loadUint(32);
+        // Check for jetton transfer opcode (0xf8a7ea5)
+        if (opCode === 0xf8a7ea5) {
+            slice.loadUint(64); // query_id
+            const jettonAmount = slice.loadCoins();
+            const destination = slice.loadAddress();
+            if (!destination) {
+                return displayInfo;
+            }
+            // Override for jetton transfer
+            displayInfo.jettonAddress = firstMessage.address;
+            displayInfo.jettonAmount = jettonAmount.toString();
+            displayInfo.recipient = destination.toString({
+                bounceable: false,
+                urlSafe: true,
+            });
+        }
+    }
+    catch (_) {
+        // If parsing fails, keep default values for a simple transfer
+    }
+    return displayInfo;
+};
+
+exports.extractDisplayInfoFromRequest = extractDisplayInfoFromRequest;

package/src/utils/extractDisplayInfoFromRequest/extractDisplayInfoFromRequest.d.ts

@@ -0,0 +1,18 @@
+import { SendTransactionRequest } from '../../types';
+export interface TransactionRequestDisplayInfo {
+    /** Primary recipient address */
+    recipient: string;
+    /** Native TON amount being sent (in nanotons) */
+    value?: string;
+    /** Jetton wallet address (if this is a jetton transfer) */
+    jettonAddress?: string;
+    /** Jetton amount being sent (in base units) */
+    jettonAmount?: string;
+}
+/**
+ * Extracts display information from a SendTransactionRequest
+ *
+ * @param request - TON Connect SendTransactionRequest
+ * @returns Display information for UI confirmation
+ */
+export declare const extractDisplayInfoFromRequest: (request: SendTransactionRequest) => TransactionRequestDisplayInfo;

package/src/utils/extractDisplayInfoFromRequest/extractDisplayInfoFromRequest.js

@@ -0,0 +1,47 @@
+'use client'
+import { Cell } from '@ton/ton';
+
+/**
+ * Extracts display information from a SendTransactionRequest
+ *
+ * @param request - TON Connect SendTransactionRequest
+ * @returns Display information for UI confirmation
+ */
+const extractDisplayInfoFromRequest = (request) => {
+    const [firstMessage] = request.messages;
+    const displayInfo = {
+        recipient: firstMessage.address,
+        value: firstMessage.amount,
+    };
+    // If there is no payload, return the default display info for a simple transfer
+    if (!firstMessage.payload) {
+        return displayInfo;
+    }
+    try {
+        const payloadCell = Cell.fromBase64(firstMessage.payload);
+        const slice = payloadCell.beginParse();
+        const opCode = slice.loadUint(32);
+        // Check for jetton transfer opcode (0xf8a7ea5)
+        if (opCode === 0xf8a7ea5) {
+            slice.loadUint(64); // query_id
+            const jettonAmount = slice.loadCoins();
+            const destination = slice.loadAddress();
+            if (!destination) {
+                return displayInfo;
+            }
+            // Override for jetton transfer
+            displayInfo.jettonAddress = firstMessage.address;
+            displayInfo.jettonAmount = jettonAmount.toString();
+            displayInfo.recipient = destination.toString({
+                bounceable: false,
+                urlSafe: true,
+            });
+        }
+    }
+    catch (_) {
+        // If parsing fails, keep default values for a simple transfer
+    }
+    return displayInfo;
+};
+
+export { extractDisplayInfoFromRequest };

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

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

package/src/utils/generateTonConnectProofHash/generateTonConnectProofHash.cjs

@@ -0,0 +1,89 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var crypto = require('@ton/crypto');
+var ton = require('@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 = ton.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) => _tslib.__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 crypto.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 crypto.sha256(fullMsg)));
+    return hash.toString('hex');
+});
+
+exports.generateTonConnectProofHash = generateTonConnectProofHash;

package/src/utils/generateTonConnectProofHash/generateTonConnectProofHash.d.ts

@@ -0,0 +1,24 @@
+import type { TonConnectDomain } from '../../types';
+export interface GenerateTonConnectProofHashParams {
+    /** Wallet address string */
+    address: string;
+    /** Domain information for TON Connect */
+    domain: TonConnectDomain;
+    /** Unix timestamp in seconds */
+    timestamp: number;
+    /** Payload string to include in the proof */
+    payload: string;
+}
+/**
+ * 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
+ */
+export declare const generateTonConnectProofHash: (params: GenerateTonConnectProofHashParams) => Promise<string>;