@ton/ton 16.0.0 → 16.2.0

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

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Builder, Cell, MessageRelaxed, OutActionSendMsg } from "@ton/core";
+import { Builder, Cell, MessageRelaxed, OutActionSendMsg, SignatureDomain } from "@ton/core";
 import { Maybe } from "../../utils/maybe";
 import { WalletV5BetaPackedCell, WalletV5BetaSendArgs, WalletV5BetaSendArgsExtensionAuth } from "../v5beta/WalletContractV5Beta";
 import { WalletV3SendArgsSignable, WalletV3SendArgsSigned } from "../WalletContractV3Types";
@@ -17,6 +17,7 @@ export declare function createWalletTransferV1(args: {
     sendMode: number;
     message: Maybe<MessageRelaxed>;
     secretKey: Buffer;
+    domain?: SignatureDomain;
 }): Cell;
 export declare function createWalletTransferV2(args: {
     seqno: number;
@@ -24,25 +25,32 @@ export declare function createWalletTransferV2(args: {
     messages: MessageRelaxed[];
     secretKey: Buffer;
     timeout?: Maybe<number>;
+    domain?: SignatureDomain;
 }): Cell;
 export declare function createWalletTransferV3<T extends WalletV3SendArgsSignable | WalletV3SendArgsSigned>(args: T & {
     sendMode: number;
     walletId: number;
+    domain?: SignatureDomain;
 }): T extends WalletV3SendArgsSignable ? Promise<Cell> : Cell;
 export declare function createWalletTransferV4<T extends WalletV4SendArgs & {
     action: OutActionWalletV4;
 }>(args: T & {
     walletId: number;
+    domain?: SignatureDomain;
 }): T extends WalletV4SendArgsSignable ? Promise<Cell> : Cell;
-export declare function createWalletTransferV5Beta<T extends WalletV5BetaSendArgs>(args: T extends WalletV5BetaSendArgsExtensionAuth ? T & {
+export declare function createWalletTransferV5Beta<T extends WalletV5BetaSendArgs>(args: (T extends WalletV5BetaSendArgsExtensionAuth ? T & {
     actions: (OutActionSendMsg | OutActionExtended)[];
 } : T & {
     actions: (OutActionSendMsg | OutActionExtended)[];
     walletId: (builder: Builder) => void;
+}) & {
+    domain?: SignatureDomain;
 }): WalletV5BetaPackedCell<T>;
-export declare function createWalletTransferV5R1<T extends WalletV5R1SendArgs>(args: T extends Wallet5VR1SendArgsExtensionAuth ? T & {
+export declare function createWalletTransferV5R1<T extends WalletV5R1SendArgs>(args: (T extends Wallet5VR1SendArgsExtensionAuth ? T & {
     actions: (OutActionSendMsg | OutActionExtended)[];
 } : T & {
     actions: (OutActionSendMsg | OutActionExtended)[];
     walletId: (builder: Builder) => void;
+}) & {
+    domain?: SignatureDomain;
 }): WalletV5R1PackedCell<T>;

package/dist/wallets/signing/createWalletTransfer.js

@@ -14,7 +14,6 @@ exports.createWalletTransferV4 = createWalletTransferV4;
 exports.createWalletTransferV5Beta = createWalletTransferV5Beta;
 exports.createWalletTransferV5R1 = createWalletTransferV5R1;
 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");
@@ -37,14 +36,17 @@ function packSignatureToTail(signature, signingMessage) {
 }
 function createWalletTransferV1(args) {
     // Create message
-    let signingMessage = (0, core_1.beginCell)()
-        .storeUint(args.seqno, 32);
+    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);
+    let signature = (0, core_1.domainSign)({
+        data: signingMessage.endCell().hash(),
+        secretKey: args.secretKey,
+        domain: args.domain,
+    });
     // Body
     const body = (0, core_1.beginCell)()
         .storeBuffer(signature)
@@ -58,8 +60,7 @@ function createWalletTransferV2(args) {
         throw Error("Maximum number of messages in a single transfer is 4");
     }
     // Create message
-    let signingMessage = (0, core_1.beginCell)()
-        .storeUint(args.seqno, 32);
+    let signingMessage = (0, core_1.beginCell)().storeUint(args.seqno, 32);
     if (args.seqno === 0) {
         for (let i = 0; i < 32; i++) {
             signingMessage.storeBit(1);
@@ -73,7 +74,11 @@ function createWalletTransferV2(args) {
         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);
+    let signature = (0, core_1.domainSign)({
+        data: signingMessage.endCell().hash(),
+        secretKey: args.secretKey,
+        domain: args.domain,
+    });
     // Body
     const body = (0, core_1.beginCell)()
         .storeBuffer(signature)
@@ -87,8 +92,7 @@ function createWalletTransferV3(args) {
         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);
+    let signingMessage = (0, core_1.beginCell)().storeUint(args.walletId, 32);
     if (args.seqno === 0) {
         for (let i = 0; i < 32; i++) {
             signingMessage.storeBit(1);
@@ -105,8 +109,7 @@ function createWalletTransferV3(args) {
     return (0, singer_1.signPayload)(args, signingMessage, packSignatureToFront);
 }
 function createWalletTransferV4(args) {
-    let signingMessage = (0, core_1.beginCell)()
-        .storeUint(args.walletId, 32);
+    let signingMessage = (0, core_1.beginCell)().storeUint(args.walletId, 32);
     if (args.seqno === 0) {
         for (let i = 0; i < 32; i++) {
             signingMessage.storeBit(1);
@@ -124,14 +127,14 @@ function createWalletTransferV5Beta(args) {
     if (args.actions.length > 255) {
         throw Error("Maximum number of OutActions in a single request is 255");
     }
-    if (args.authType === 'extension') {
+    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'
+        .storeUint(args.authType === "internal"
         ? WalletContractV5Beta_1.WalletContractV5Beta.OpCodes.auth_signed_internal
         : WalletContractV5Beta_1.WalletContractV5Beta.OpCodes.auth_signed_external, 32)
         .store(args.walletId);
@@ -154,7 +157,7 @@ function createWalletTransferV5R1(args) {
         throw Error("Maximum number of OutActions in a single request is 255");
     }
     args = { ...args };
-    if (args.authType === 'extension') {
+    if (args.authType === "extension") {
         return (0, core_1.beginCell)()
             .storeUint(WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_extension, 32)
             .storeUint(args.queryId ?? 0, 64)
@@ -163,7 +166,7 @@ function createWalletTransferV5R1(args) {
     }
     args.actions = (0, WalletV5R1Actions_1.patchV5R1ActionsSendMode)(args.actions, args.authType);
     const signingMessage = (0, core_1.beginCell)()
-        .storeUint(args.authType === 'internal'
+        .storeUint(args.authType === "internal"
         ? WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_signed_internal
         : WalletContractV5R1_1.WalletContractV5R1.OpCodes.auth_signed_external, 32)
         .store(args.walletId);

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

@@ -1,6 +1,7 @@
-import { Builder, Cell } from "@ton/core";
+import { Builder, Cell, SignatureDomain } from "@ton/core";
 export type SendArgsSigned = {
     secretKey: Buffer;
+    domain?: SignatureDomain;
 };
 export type SendArgsSignable = {
     signer: (message: Cell) => Promise<Buffer>;

package/dist/wallets/signing/singer.js

@@ -1,20 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signPayload = signPayload;
-const crypto_1 = require("@ton/crypto");
+const core_1 = require("@ton/core");
 function signPayload(args, signingMessage, packMessage) {
-    if ('secretKey' in args) {
+    if ("secretKey" in args) {
         /**
          * Client provider an secretKey to sign transaction.
          */
-        return packMessage((0, crypto_1.sign)(signingMessage.endCell().hash(), args.secretKey), signingMessage);
+        const signature = (0, core_1.domainSign)({
+            data: signingMessage.endCell().hash(),
+            secretKey: args.secretKey,
+            domain: args.domain,
+        });
+        return packMessage(signature, 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));
+        return args
+            .signer(signingMessage.endCell())
+            .then((signature) => packMessage(signature, signingMessage));
     }
 }

package/dist/wallets/v1/r1.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode, SignatureDomain } from "@ton/core";
+import { Maybe } from "../../utils/maybe";
+export declare class WalletContractV1R1 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+        domain?: SignatureDomain;
+    }): WalletContractV1R1;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    readonly address: Address;
+    readonly init: {
+        data: Cell;
+        code: Cell;
+    };
+    domain?: SignatureDomain;
+    constructor(workchain: number, publicKey: Buffer, domain?: SignatureDomain);
+    /**
+     * Get Wallet Balance
+     */
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    /**
+     * Get Wallet Seqno
+     */
+    getSeqno(provider: ContractProvider): Promise<number>;
+    /**
+     * Send signed transfer
+     */
+    send(provider: ContractProvider, message: Cell): Promise<void>;
+    /**
+     * Sign and send transfer
+     */
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Promise<void>;
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Cell;
+    /**
+     * Create sender
+     */
+    sender(provider: ContractProvider, secretKey: Buffer): Sender;
+}

package/dist/wallets/v1/r1.js

@@ -0,0 +1,103 @@
+"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.WalletContractV1R1 = void 0;
+const core_1 = require("@ton/core");
+const createWalletTransfer_1 = require("../signing/createWalletTransfer");
+class WalletContractV1R1 {
+    static create(args) {
+        return new WalletContractV1R1(args.workchain, args.publicKey, args.domain);
+    }
+    constructor(workchain, publicKey, domain) {
+        this.workchain = workchain;
+        this.publicKey = publicKey;
+        this.domain = domain;
+        // Build initial code and data
+        let code = core_1.Cell.fromBoc(Buffer.from("te6cckEBAQEARAAAhP8AIN2k8mCBAgDXGCDXCx/tRNDTH9P/0VESuvKhIvkBVBBE+RDyovgAAdMfMSDXSpbTB9QC+wDe0aTIyx/L/8ntVEH98Ik=", "base64"))[0];
+        let data = (0, core_1.beginCell)()
+            .storeUint(0, 32) // Seqno
+            .storeBuffer(publicKey)
+            .endCell();
+        this.init = { code, data };
+        this.address = (0, core_1.contractAddress)(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") {
+            return core_1.Cell.fromBoc(state.state.data)[0].beginParse().loadUint(32);
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Send signed transfer
+     */
+    async send(provider, message) {
+        await provider.external(message);
+    }
+    /**
+     * Sign and send transfer
+     */
+    async sendTransfer(provider, args) {
+        let transfer = this.createTransfer(args);
+        await this.send(provider, transfer);
+    }
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args) {
+        let sendMode = core_1.SendMode.PAY_GAS_SEPARATELY;
+        if (args.sendMode !== null && args.sendMode !== undefined) {
+            sendMode = args.sendMode;
+        }
+        return (0, createWalletTransfer_1.createWalletTransferV1)({
+            seqno: args.seqno,
+            sendMode,
+            secretKey: args.secretKey,
+            message: args.message,
+            domain: this.domain,
+        });
+    }
+    /**
+     * Create sender
+     */
+    sender(provider, secretKey) {
+        return {
+            send: async (args) => {
+                let seqno = await this.getSeqno(provider);
+                let transfer = this.createTransfer({
+                    seqno,
+                    secretKey,
+                    sendMode: args.sendMode,
+                    message: (0, core_1.internal)({
+                        to: args.to,
+                        value: args.value,
+                        extracurrency: args.extracurrency,
+                        init: args.init,
+                        body: args.body,
+                        bounce: args.bounce,
+                    }),
+                });
+                await this.send(provider, transfer);
+            },
+        };
+    }
+}
+exports.WalletContractV1R1 = WalletContractV1R1;

package/dist/wallets/v1/r2.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode, SignatureDomain } from "@ton/core";
+import { Maybe } from "../../utils/maybe";
+export declare class WalletContractV1R2 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+        domain?: SignatureDomain;
+    }): WalletContractV1R2;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    readonly address: Address;
+    readonly init: {
+        data: Cell;
+        code: Cell;
+    };
+    domain?: SignatureDomain;
+    constructor(workchain: number, publicKey: Buffer, domain?: SignatureDomain);
+    /**
+     * Get Wallet Balance
+     */
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    /**
+     * Get Wallet Seqno
+     */
+    getSeqno(provider: ContractProvider): Promise<number>;
+    /**
+     * Send signed transfer
+     */
+    send(provider: ContractProvider, message: Cell): Promise<void>;
+    /**
+     * Sign and send transfer
+     */
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Promise<void>;
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Cell;
+    /**
+     * Create sender
+     */
+    sender(provider: ContractProvider, secretKey: Buffer): Sender;
+}

package/dist/wallets/v1/r2.js

@@ -0,0 +1,104 @@
+"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.WalletContractV1R2 = void 0;
+const core_1 = require("@ton/core");
+const createWalletTransfer_1 = require("../signing/createWalletTransfer");
+class WalletContractV1R2 {
+    static create(args) {
+        return new WalletContractV1R2(args.workchain, args.publicKey, args.domain);
+    }
+    constructor(workchain, publicKey, domain) {
+        this.workchain = workchain;
+        this.publicKey = publicKey;
+        this.domain = domain;
+        // Build initial code and data
+        let code = core_1.Cell.fromBoc(Buffer.from("te6cckEBAQEAUwAAov8AIN0gggFMl7qXMO1E0NcLH+Ck8mCBAgDXGCDXCx/tRNDTH9P/0VESuvKhIvkBVBBE+RDyovgAAdMfMSDXSpbTB9QC+wDe0aTIyx/L/8ntVNDieG8=", "base64"))[0];
+        let data = (0, core_1.beginCell)()
+            .storeUint(0, 32) // Seqno
+            .storeBuffer(publicKey)
+            .endCell();
+        this.init = { code, data };
+        this.address = (0, core_1.contractAddress)(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;
+        }
+    }
+    /**
+     * Send signed transfer
+     */
+    async send(provider, message) {
+        await provider.external(message);
+    }
+    /**
+     * Sign and send transfer
+     */
+    async sendTransfer(provider, args) {
+        let transfer = this.createTransfer(args);
+        await this.send(provider, transfer);
+    }
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args) {
+        let sendMode = core_1.SendMode.PAY_GAS_SEPARATELY;
+        if (args.sendMode !== null && args.sendMode !== undefined) {
+            sendMode = args.sendMode;
+        }
+        return (0, createWalletTransfer_1.createWalletTransferV1)({
+            seqno: args.seqno,
+            sendMode,
+            secretKey: args.secretKey,
+            message: args.message,
+            domain: this.domain,
+        });
+    }
+    /**
+     * Create sender
+     */
+    sender(provider, secretKey) {
+        return {
+            send: async (args) => {
+                let seqno = await this.getSeqno(provider);
+                let transfer = this.createTransfer({
+                    seqno,
+                    secretKey,
+                    sendMode: args.sendMode,
+                    message: (0, core_1.internal)({
+                        to: args.to,
+                        value: args.value,
+                        extracurrency: args.extracurrency,
+                        init: args.init,
+                        body: args.body,
+                        bounce: args.bounce,
+                    }),
+                });
+                await this.send(provider, transfer);
+            },
+        };
+    }
+}
+exports.WalletContractV1R2 = WalletContractV1R2;

package/dist/wallets/v1/r3.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode, SignatureDomain } from "@ton/core";
+import { Maybe } from "../../utils/maybe";
+export declare class WalletContractV1R3 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+        domain?: SignatureDomain;
+    }): WalletContractV1R3;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    readonly address: Address;
+    readonly init: {
+        data: Cell;
+        code: Cell;
+    };
+    domain?: SignatureDomain;
+    constructor(workchain: number, publicKey: Buffer, domain?: SignatureDomain);
+    /**
+     * Get Wallet Balance
+     */
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    /**
+     * Get Wallet Seqno
+     */
+    getSeqno(provider: ContractProvider): Promise<number>;
+    /**
+     * Send signed transfer
+     */
+    send(executor: ContractProvider, message: Cell): Promise<void>;
+    /**
+     * Sign and send transfer
+     */
+    sendTransfer(provider: ContractProvider, args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Promise<void>;
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args: {
+        seqno: number;
+        secretKey: Buffer;
+        message?: Maybe<MessageRelaxed>;
+        sendMode?: Maybe<SendMode>;
+    }): Cell;
+    /**
+     * Create sender
+     */
+    sender(provider: ContractProvider, secretKey: Buffer): Sender;
+}

package/dist/wallets/v1/r3.js

@@ -0,0 +1,103 @@
+"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.WalletContractV1R3 = void 0;
+const core_1 = require("@ton/core");
+const createWalletTransfer_1 = require("../signing/createWalletTransfer");
+class WalletContractV1R3 {
+    static create(args) {
+        return new WalletContractV1R3(args.workchain, args.publicKey, args.domain);
+    }
+    constructor(workchain, publicKey, domain) {
+        this.workchain = workchain;
+        this.publicKey = publicKey;
+        this.domain = domain;
+        // Build initial code and data
+        let code = core_1.Cell.fromBoc(Buffer.from("te6cckEBAQEAXwAAuv8AIN0gggFMl7ohggEznLqxnHGw7UTQ0x/XC//jBOCk8mCBAgDXGCDXCx/tRNDTH9P/0VESuvKhIvkBVBBE+RDyovgAAdMfMSDXSpbTB9QC+wDe0aTIyx/L/8ntVLW4bkI=", "base64"))[0];
+        let data = (0, core_1.beginCell)()
+            .storeUint(0, 32) // Seqno
+            .storeBuffer(publicKey)
+            .endCell();
+        this.init = { code, data };
+        this.address = (0, core_1.contractAddress)(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;
+        }
+    }
+    /**
+     * Send signed transfer
+     */
+    async send(executor, message) {
+        await executor.external(message);
+    }
+    /**
+     * Sign and send transfer
+     */
+    async sendTransfer(provider, args) {
+        let transfer = this.createTransfer(args);
+        await this.send(provider, transfer);
+    }
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args) {
+        let sendMode = core_1.SendMode.PAY_GAS_SEPARATELY;
+        if (args.sendMode !== null && args.sendMode !== undefined) {
+            sendMode = args.sendMode;
+        }
+        return (0, createWalletTransfer_1.createWalletTransferV1)({
+            seqno: args.seqno,
+            sendMode: sendMode,
+            secretKey: args.secretKey,
+            message: args.message,
+            domain: this.domain,
+        });
+    }
+    /**
+     * Create sender
+     */
+    sender(provider, secretKey) {
+        return {
+            send: async (args) => {
+                let seqno = await this.getSeqno(provider);
+                let transfer = this.createTransfer({
+                    seqno,
+                    secretKey,
+                    sendMode: args.sendMode,
+                    message: (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.WalletContractV1R3 = WalletContractV1R3;