@ton-wallet/create 14.0.6 → 14.0.7

package/dist/wallets/signing/createWalletTransfer.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWalletTransferV5R1 = exports.createWalletTransferV5Beta = exports.createWalletTransferV4 = exports.createWalletTransferV3 = exports.createWalletTransferV2 = exports.createWalletTransferV1 = void 0;
+const core_1 = require("@ton/core");
+const crypto_1 = require("@ton/crypto");
+const WalletContractV5Beta_1 = require("../v5beta/WalletContractV5Beta");
+const WalletV5BetaActions_1 = require("../v5beta/WalletV5BetaActions");
+const singer_1 = require("./singer");
+const WalletContractV5R1_1 = require("../v5r1/WalletContractV5R1");
+const WalletV5R1Actions_1 = require("../v5r1/WalletV5R1Actions");
+function packSignatureToFront(signature, signingMessage) {
+    const body = (0, core_1.beginCell)()
+        .storeBuffer(signature)
+        .storeBuilder(signingMessage)
+        .endCell();
+    return body;
+}
+function packSignatureToTail(signature, signingMessage) {
+    const body = (0, core_1.beginCell)()
+        .storeBuilder(signingMessage)
+        .storeBuffer(signature)
+        .endCell();
+    return body;
+}
+function createWalletTransferV1(args) {
+    // Create message
+    let signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.seqno, 32);
+    if (args.message) {
+        signingMessage.storeUint(args.sendMode, 8);
+        signingMessage.storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(args.message)));
+    }
+    // Sign message
+    let signature = (0, crypto_1.sign)(signingMessage.endCell().hash(), args.secretKey);
+    // Body
+    const body = (0, core_1.beginCell)()
+        .storeBuffer(signature)
+        .storeBuilder(signingMessage)
+        .endCell();
+    return body;
+}
+exports.createWalletTransferV1 = createWalletTransferV1;
+function createWalletTransferV2(args) {
+    // Check number of messages
+    if (args.messages.length > 4) {
+        throw Error("Maximum number of messages in a single transfer is 4");
+    }
+    // Create message
+    let signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.seqno, 32);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    for (let m of args.messages) {
+        signingMessage.storeUint(args.sendMode, 8);
+        signingMessage.storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(m)));
+    }
+    // Sign message
+    let signature = (0, crypto_1.sign)(signingMessage.endCell().hash(), args.secretKey);
+    // Body
+    const body = (0, core_1.beginCell)()
+        .storeBuffer(signature)
+        .storeBuilder(signingMessage)
+        .endCell();
+    return body;
+}
+exports.createWalletTransferV2 = createWalletTransferV2;
+function createWalletTransferV3(args) {
+    // Check number of messages
+    if (args.messages.length > 4) {
+        throw Error("Maximum number of messages in a single transfer is 4");
+    }
+    // Create message to sign
+    let signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.walletId, 32);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    signingMessage.storeUint(args.seqno, 32);
+    for (let m of args.messages) {
+        signingMessage.storeUint(args.sendMode, 8);
+        signingMessage.storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(m)));
+    }
+    return (0, singer_1.signPayload)(args, signingMessage, packSignatureToFront);
+}
+exports.createWalletTransferV3 = createWalletTransferV3;
+function createWalletTransferV4(args) {
+    // Check number of messages
+    if (args.messages.length > 4) {
+        throw Error("Maximum number of messages in a single transfer is 4");
+    }
+    let signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.walletId, 32);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    signingMessage.storeUint(args.seqno, 32);
+    signingMessage.storeUint(0, 8); // Simple order
+    for (let m of args.messages) {
+        signingMessage.storeUint(args.sendMode, 8);
+        signingMessage.storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(m)));
+    }
+    return (0, singer_1.signPayload)(args, signingMessage, packSignatureToFront);
+}
+exports.createWalletTransferV4 = createWalletTransferV4;
+function createWalletTransferV5Beta(args) {
+    // Check number of actions
+    if (args.actions.length > 255) {
+        throw Error("Maximum number of OutActions in a single request is 255");
+    }
+    if (args.authType === 'extension') {
+        return (0, core_1.beginCell)()
+            .storeUint(WalletContractV5Beta_1.WalletContractV5Beta.OpCodes.auth_extension, 32)
+            .store((0, WalletV5BetaActions_1.storeOutListExtendedV5Beta)(args.actions))
+            .endCell();
+    }
+    const signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.authType === 'internal'
+        ? WalletContractV5Beta_1.WalletContractV5Beta.OpCodes.auth_signed_internal
+        : WalletContractV5Beta_1.WalletContractV5Beta.OpCodes.auth_signed_external, 32)
+        .store(args.walletId);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    signingMessage
+        .storeUint(args.seqno, 32)
+        .store((0, WalletV5BetaActions_1.storeOutListExtendedV5Beta)(args.actions));
+    return (0, singer_1.signPayload)(args, signingMessage, packSignatureToTail);
+}
+exports.createWalletTransferV5Beta = createWalletTransferV5Beta;
+function createWalletTransferV5R1(args) {
+    // Check number of actions
+    if (args.actions.length > 255) {
+        throw Error("Maximum number of OutActions in a single request is 255");
+    }
+    args = { ...args };
+    if (args.authType === 'extension') {
+        return (0, core_1.beginCell)()
+            .storeUint(WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_extension, 32)
+            .storeUint(args.queryId ?? 0, 64)
+            .store((0, WalletV5R1Actions_1.storeOutListExtendedV5R1)(args.actions))
+            .endCell();
+    }
+    args.actions = (0, WalletV5R1Actions_1.patchV5R1ActionsSendMode)(args.actions, args.authType);
+    const signingMessage = (0, core_1.beginCell)()
+        .storeUint(args.authType === 'internal'
+        ? WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_signed_internal
+        : WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_signed_external, 32)
+        .store(args.walletId);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    signingMessage
+        .storeUint(args.seqno, 32)
+        .store((0, WalletV5R1Actions_1.storeOutListExtendedV5R1)(args.actions));
+    return (0, singer_1.signPayload)(args, signingMessage, packSignatureToTail);
+}
+exports.createWalletTransferV5R1 = createWalletTransferV5R1;

package/dist/wallets/signing/singer.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Builder, Cell } from "@ton/core";
+export type SendArgsSigned = {
+    secretKey: Buffer;
+};
+export type SendArgsSignable = {
+    signer: (message: Cell) => Promise<Buffer>;
+};
+export declare function signPayload<T extends SendArgsSigned | SendArgsSignable>(args: T, signingMessage: Builder, packMessage: (signature: Buffer, signingMessage: Builder) => Cell): T extends SendArgsSignable ? Promise<Cell> : Cell;

package/dist/wallets/signing/singer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signPayload = void 0;
+const crypto_1 = require("@ton/crypto");
+function signPayload(args, signingMessage, packMessage) {
+    if ('secretKey' in args) {
+        /**
+         * Client provider an secretKey to sign transaction.
+         */
+        return packMessage((0, crypto_1.sign)(signingMessage.endCell().hash(), args.secretKey), signingMessage);
+    }
+    else {
+        /**
+         * Client use external storage for secretKey.
+         * In this case lib could create a request to external resource to sign transaction.
+         */
+        return args.signer(signingMessage.endCell())
+            .then(signature => packMessage(signature, signingMessage));
+    }
+}
+exports.signPayload = signPayload;

package/dist/wallets/v5beta/WalletContractV5Beta.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode } from "@ton/core";
+import { Maybe } from "../../utils/maybe";
+import { SendArgsSignable, SendArgsSigned } from "../signing/singer";
+import { OutActionWalletV5 } from "./WalletV5OutActions";
+import { WalletIdV5Beta } from "./WalletV5BetaWalletId";
+export type WalletV5BetaBasicSendArgs = {
+    seqno: number;
+    timeout?: Maybe<number>;
+};
+export type WalletV5BetaSendArgsSigned = WalletV5BetaBasicSendArgs & SendArgsSigned & {
+    authType?: 'external' | 'internal';
+};
+export type WalletV5BetaSendArgsSignable = WalletV5BetaBasicSendArgs & SendArgsSignable & {
+    authType?: 'external' | 'internal';
+};
+export type WalletV5BetaSendArgsExtensionAuth = WalletV5BetaBasicSendArgs & {
+    authType: 'extension';
+};
+export type WalletV5BetaSendArgs = WalletV5BetaSendArgsSigned | WalletV5BetaSendArgsSignable | WalletV5BetaSendArgsExtensionAuth;
+export type WalletV5BetaPackedCell<T> = T extends WalletV5BetaSendArgsSignable ? Promise<Cell> : Cell;
+/**
+ * @deprecated
+ * use WalletContractV5R1 instead
+ */
+export declare class WalletContractV5Beta implements Contract {
+    readonly walletId: WalletIdV5Beta;
+    readonly publicKey: Buffer;
+    static OpCodes: {
+        auth_extension: number;
+        auth_signed_external: number;
+        auth_signed_internal: number;
+    };
+    static create(args: {
+        walletId?: Partial<WalletIdV5Beta>;
+        publicKey: Buffer;
+    }): WalletContractV5Beta;
+    readonly address: Address;
+    readonly init: {
+        data: Cell;
+        code: Cell;
+    };
+    private constructor();
+    /**
+     * Get Wallet Balance
+     */
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    /**
+     * Get Wallet Seqno
+     */
+    getSeqno(provider: ContractProvider): Promise<number>;
+    /**
+     * Get Wallet Extensions
+     */
+    getExtensions(provider: ContractProvider): Promise<Cell | null>;
+    /**
+     * Get Wallet Extensions
+     */
+    getExtensionsArray(provider: ContractProvider): Promise<Address[]>;
+    /**
+     * Get is secret-key authentication enabled
+     */
+    getIsSecretKeyAuthEnabled(provider: ContractProvider): Promise<boolean>;
+    /**
+     * Send signed transfer
+     */
+    send(provider: ContractProvider, message: Cell): Promise<void>;
+    /**
+     * Sign and send transfer
+     */
+    sendTransfer(provider: ContractProvider, args: WalletV5BetaSendArgs & {
+        messages: MessageRelaxed[];
+        sendMode: SendMode;
+    }): Promise<void>;
+    /**
+     * Sign and send add extension request
+     */
+    sendAddExtension(provider: ContractProvider, args: WalletV5BetaSendArgs & {
+        extensionAddress: Address;
+    }): Promise<void>;
+    /**
+     * Sign and send remove extension request
+     */
+    sendRemoveExtension(provider: ContractProvider, args: WalletV5BetaSendArgs & {
+        extensionAddress: Address;
+    }): Promise<void>;
+    /**
+     * Sign and send actions batch
+     */
+    sendActionsBatch(provider: ContractProvider, args: WalletV5BetaSendArgs & {
+        actions: OutActionWalletV5[];
+    }): Promise<void>;
+    private createActions;
+    /**
+     * Create signed transfer
+     */
+    createTransfer<T extends WalletV5BetaSendArgs>(args: T & {
+        messages: MessageRelaxed[];
+        sendMode: SendMode;
+    }): WalletV5BetaPackedCell<T>;
+    /**
+     * Create signed add extension request
+     */
+    createAddExtension<T extends WalletV5BetaSendArgs>(args: T & {
+        extensionAddress: Address;
+    }): WalletV5BetaPackedCell<T>;
+    /**
+     * Create signed remove extension request
+     */
+    createRemoveExtension<T extends WalletV5BetaSendArgs>(args: T & {
+        extensionAddress: Address;
+    }): WalletV5BetaPackedCell<T>;
+    /**
+     * Create signed request or extension auth request
+     */
+    createRequest<T extends WalletV5BetaSendArgs>(args: T & {
+        actions: OutActionWalletV5[];
+    }): WalletV5BetaPackedCell<T>;
+    /**
+     * Create sender
+     */
+    sender(provider: ContractProvider, secretKey: Buffer): Sender;
+}

package/dist/wallets/v5beta/WalletContractV5Beta.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletContractV5Beta = void 0;
+const core_1 = require("@ton/core");
+const createWalletTransfer_1 = require("../signing/createWalletTransfer");
+const WalletV5BetaWalletId_1 = require("./WalletV5BetaWalletId");
+/**
+ * @deprecated
+ * use WalletContractV5R1 instead
+ */
+class WalletContractV5Beta {
+    static create(args) {
+        const walletId = {
+            networkGlobalId: args.walletId?.networkGlobalId ?? -239,
+            workchain: args?.walletId?.workchain ?? 0,
+            subwalletNumber: args?.walletId?.subwalletNumber ?? 0,
+            walletVersion: args?.walletId?.walletVersion ?? 'v5'
+        };
+        return new WalletContractV5Beta(walletId, args.publicKey);
+    }
+    constructor(walletId, publicKey) {
+        this.walletId = walletId;
+        this.publicKey = publicKey;
+        this.walletId = walletId;
+        // https://github.com/tonkeeper/w5/commit/fa1b372a417a32af104fe1b949b6b31d29cee349 code with library
+        let code = core_1.Cell.fromBoc(Buffer.from('te6cckEBAQEAIwAIQgLkzzsvTG1qYeoPK1RH0mZ4WyavNjfbLe7mvNGqgm80Eg3NjhE=', 'base64'))[0];
+        let data = (0, core_1.beginCell)()
+            .storeInt(0, 33) // Seqno
+            .store((0, WalletV5BetaWalletId_1.storeWalletIdV5Beta)(this.walletId))
+            .storeBuffer(this.publicKey, 32)
+            .storeBit(0) // Empty plugins dict
+            .endCell();
+        this.init = { code, data };
+        this.address = (0, core_1.contractAddress)(this.walletId.workchain, { code, data });
+    }
+    /**
+     * Get Wallet Balance
+     */
+    async getBalance(provider) {
+        let state = await provider.getState();
+        return state.balance;
+    }
+    /**
+     * Get Wallet Seqno
+     */
+    async getSeqno(provider) {
+        let state = await provider.getState();
+        if (state.state.type === 'active') {
+            let res = await provider.get('seqno', []);
+            return res.stack.readNumber();
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Get Wallet Extensions
+     */
+    async getExtensions(provider) {
+        let state = await provider.getState();
+        if (state.state.type === 'active') {
+            const result = await provider.get('get_extensions', []);
+            return result.stack.readCellOpt();
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Get Wallet Extensions
+     */
+    async getExtensionsArray(provider) {
+        const extensions = await this.getExtensions(provider);
+        if (!extensions) {
+            return [];
+        }
+        const dict = core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigInt(8), extensions);
+        return dict.keys().map(key => {
+            const wc = dict.get(key);
+            const addressHex = key ^ (wc + 1n);
+            return core_1.Address.parseRaw(`${wc}:${addressHex.toString(16).padStart(64, "0")}`);
+        });
+    }
+    /**
+     * Get is secret-key authentication enabled
+     */
+    async getIsSecretKeyAuthEnabled(provider) {
+        let res = await provider.get('get_is_signature_auth_allowed', []);
+        const result = res.stack.readNumber();
+        return result !== 0;
+    }
+    /**
+     * Send signed transfer
+     */
+    async send(provider, message) {
+        await provider.external(message);
+    }
+    /**
+     * Sign and send transfer
+     */
+    async sendTransfer(provider, args) {
+        const transfer = await this.createTransfer(args);
+        await this.send(provider, transfer);
+    }
+    /**
+     * Sign and send add extension request
+     */
+    async sendAddExtension(provider, args) {
+        const request = await this.createAddExtension(args);
+        await this.send(provider, request);
+    }
+    /**
+     * Sign and send remove extension request
+     */
+    async sendRemoveExtension(provider, args) {
+        const request = await this.createRemoveExtension(args);
+        await this.send(provider, request);
+    }
+    /**
+     * Sign and send actions batch
+     */
+    async sendActionsBatch(provider, args) {
+        const request = await this.createRequest(args);
+        await this.send(provider, request);
+    }
+    createActions(args) {
+        const actions = args.messages.map(message => ({ type: 'sendMsg', mode: args.sendMode, outMsg: message }));
+        return actions;
+    }
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args) {
+        return this.createRequest({
+            ...args,
+            actions: this.createActions({ messages: args.messages, sendMode: args.sendMode })
+        });
+    }
+    /**
+     * Create signed add extension request
+     */
+    createAddExtension(args) {
+        return this.createRequest({
+            ...args,
+            actions: [{
+                    type: 'addExtension',
+                    address: args.extensionAddress
+                }]
+        });
+    }
+    /**
+     * Create signed remove extension request
+     */
+    createRemoveExtension(args) {
+        return this.createRequest({
+            ...args,
+            actions: [{
+                    type: 'removeExtension',
+                    address: args.extensionAddress
+                }]
+        });
+    }
+    /**
+     * Create signed request or extension auth request
+     */
+    createRequest(args) {
+        if (args.authType === 'extension') {
+            return (0, createWalletTransfer_1.createWalletTransferV5Beta)(args);
+        }
+        return (0, createWalletTransfer_1.createWalletTransferV5Beta)({
+            ...args,
+            walletId: (0, WalletV5BetaWalletId_1.storeWalletIdV5Beta)(this.walletId)
+        });
+    }
+    /**
+     * Create sender
+     */
+    sender(provider, secretKey) {
+        return {
+            send: async (args) => {
+                let seqno = await this.getSeqno(provider);
+                let transfer = this.createTransfer({
+                    seqno,
+                    secretKey,
+                    sendMode: args.sendMode ?? core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+                    messages: [(0, core_1.internal)({
+                            to: args.to,
+                            value: args.value,
+                            init: args.init,
+                            body: args.body,
+                            bounce: args.bounce
+                        })]
+                });
+                await this.send(provider, transfer);
+            }
+        };
+    }
+}
+exports.WalletContractV5Beta = WalletContractV5Beta;
+WalletContractV5Beta.OpCodes = {
+    auth_extension: 0x6578746e,
+    auth_signed_external: 0x7369676e,
+    auth_signed_internal: 0x73696e74
+};

package/dist/wallets/v5beta/WalletContractV5Beta.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};