@ton/ton 13.5.1

package/dist/utils/randomTestKey.js

@@ -0,0 +1,24 @@
+"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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomTestKey = void 0;
+const prando_1 = __importDefault(require("prando"));
+const crypto_1 = require("@ton/crypto");
+function randomTestKey(seed) {
+    let random = new prando_1.default(seed);
+    let res = Buffer.alloc(32);
+    for (let i = 0; i < res.length; i++) {
+        res[i] = random.nextInt(0, 256);
+    }
+    return (0, crypto_1.keyPairFromSeed)(res);
+}
+exports.randomTestKey = randomTestKey;

package/dist/utils/time.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare function exponentialBackoffDelay(currentFailureCount: number, minDelay: number, maxDelay: number, maxFailureCount: number): number;
+export declare function delay(ms: number): Promise<unknown>;
+export declare function delayBreakable(ms: number): {
+    promise: Promise<unknown>;
+    resolver: () => void;
+};
+export declare function forever(): Promise<unknown>;
+export declare function backoff<T>(callback: () => Promise<T>, log: boolean): Promise<T>;

package/dist/utils/time.js

@@ -0,0 +1,63 @@
+"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.backoff = exports.forever = exports.delayBreakable = exports.delay = exports.exponentialBackoffDelay = void 0;
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+    let maxDelayRet = minDelay + ((maxDelay - minDelay) / maxFailureCount) * Math.max(currentFailureCount, maxFailureCount);
+    return Math.round(Math.random() * maxDelayRet);
+}
+exports.exponentialBackoffDelay = exponentialBackoffDelay;
+async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.delay = delay;
+function delayBreakable(ms) {
+    // We can cancel delay from outer code
+    let promiseResolver = null;
+    let resolver = () => {
+        if (promiseResolver) {
+            promiseResolver();
+        }
+    };
+    let promise = new Promise(resolve => {
+        promiseResolver = resolve;
+        setTimeout(resolve, ms);
+    });
+    return { promise, resolver };
+}
+exports.delayBreakable = delayBreakable;
+const promise = new Promise(() => { });
+function forever() {
+    return promise;
+}
+exports.forever = forever;
+async function backoff(callback, log) {
+    let currentFailureCount = 0;
+    const minDelay = 500;
+    const maxDelay = 15000;
+    const maxFailureCount = 50;
+    while (true) {
+        try {
+            return await callback();
+        }
+        catch (e) {
+            if (currentFailureCount > 3) {
+                if (log) {
+                    console.warn(e);
+                }
+            }
+            if (currentFailureCount < maxFailureCount) {
+                currentFailureCount++;
+            }
+            let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+            await delay(waitForRequest);
+        }
+    }
+}
+exports.backoff = backoff;

package/dist/utils/toUrlSafe.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 declare function toUrlSafe(src: string): string;

package/dist/utils/toUrlSafe.js

@@ -0,0 +1,23 @@
+"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.toUrlSafe = void 0;
+function toUrlSafe(src) {
+    while (src.indexOf('/') >= 0) {
+        src = src.replace('/', '_');
+    }
+    while (src.indexOf('+') >= 0) {
+        src = src.replace('+', '-');
+    }
+    while (src.indexOf('=') >= 0) {
+        src = src.replace('=', '');
+    }
+    return src;
+}
+exports.toUrlSafe = toUrlSafe;

package/dist/wallets/WalletContractV1R1.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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";
+export declare class WalletContractV1R1 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+    }): WalletContractV1R1;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    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>;
+    /**
+     * 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/WalletContractV1R1.js

@@ -0,0 +1,100 @@
+"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 {
+    constructor(workchain, publicKey) {
+        this.workchain = workchain;
+        this.publicKey = publicKey;
+        // 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 });
+    }
+    static create(args) {
+        return new WalletContractV1R1(args.workchain, args.publicKey);
+    }
+    /**
+     * 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
+        });
+    }
+    /**
+     * 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.WalletContractV1R1 = WalletContractV1R1;

package/dist/wallets/WalletContractV1R1.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 {};

package/dist/wallets/WalletContractV1R1.spec.js

@@ -0,0 +1,44 @@
+"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 });
+const randomTestKey_1 = require("../utils/randomTestKey");
+const createTestClient4_1 = require("../utils/createTestClient4");
+const core_1 = require("@ton/core");
+const WalletContractV1R1_1 = require("./WalletContractV1R1");
+describe('WalletContractV1R1', () => {
+    it('should has balance and correct address', async () => {
+        // Create contract
+        let client = (0, createTestClient4_1.createTestClient4)();
+        let key = (0, randomTestKey_1.randomTestKey)('v4-treasure');
+        let contract = client.open(WalletContractV1R1_1.WalletContractV1R1.create({ workchain: 0, publicKey: key.publicKey }));
+        let balance = await contract.getBalance();
+        // Check parameters
+        expect(contract.address.equals(core_1.Address.parse('EQCtW_zzk6n82ebaVQFq8P_04wOemYhtwqMd3NuArmPODRvD'))).toBe(true);
+        expect(balance > 0n).toBe(true);
+    });
+    it('should perform transfer', async () => {
+        // Create contract
+        let client = (0, createTestClient4_1.createTestClient4)();
+        let key = (0, randomTestKey_1.randomTestKey)('v4-treasure');
+        let contract = client.open(WalletContractV1R1_1.WalletContractV1R1.create({ workchain: 0, publicKey: key.publicKey }));
+        // Prepare transfer
+        let seqno = await contract.getSeqno();
+        let transfer = contract.createTransfer({
+            seqno,
+            secretKey: key.secretKey,
+            message: (0, core_1.internal)({
+                to: 'kQD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgtwt',
+                value: '0.1',
+                body: 'Hello, world!'
+            })
+        });
+        // Perform transfer
+        await contract.send(transfer);
+    });
+});

package/dist/wallets/WalletContractV1R2.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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";
+export declare class WalletContractV1R2 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+    }): WalletContractV1R2;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    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>;
+    /**
+     * 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/WalletContractV1R2.js

@@ -0,0 +1,101 @@
+"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 {
+    constructor(workchain, publicKey) {
+        this.workchain = workchain;
+        this.publicKey = publicKey;
+        // 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 });
+    }
+    static create(args) {
+        return new WalletContractV1R2(args.workchain, args.publicKey);
+    }
+    /**
+     * 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
+        });
+    }
+    /**
+     * 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.WalletContractV1R2 = WalletContractV1R2;

package/dist/wallets/WalletContractV1R2.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 {};

package/dist/wallets/WalletContractV1R2.spec.js

@@ -0,0 +1,44 @@
+"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 });
+const randomTestKey_1 = require("../utils/randomTestKey");
+const createTestClient4_1 = require("../utils/createTestClient4");
+const core_1 = require("@ton/core");
+const WalletContractV1R2_1 = require("./WalletContractV1R2");
+describe('WalletContractV1R2', () => {
+    it('should has balance and correct address', async () => {
+        // Create contract
+        let client = (0, createTestClient4_1.createTestClient4)();
+        let key = (0, randomTestKey_1.randomTestKey)('v4-treasure');
+        let contract = client.open(WalletContractV1R2_1.WalletContractV1R2.create({ workchain: 0, publicKey: key.publicKey }));
+        let balance = await contract.getBalance();
+        // Check parameters
+        expect(contract.address.equals(core_1.Address.parse('EQATDkvcCA2fFWbSTHMpGCrjkNGqgEywES15ZS11HHY3UuxK'))).toBe(true);
+        expect(balance > 0n).toBe(true);
+    });
+    it('should perform transfer', async () => {
+        // Create contract
+        let client = (0, createTestClient4_1.createTestClient4)();
+        let key = (0, randomTestKey_1.randomTestKey)('v4-treasure');
+        let contract = client.open(WalletContractV1R2_1.WalletContractV1R2.create({ workchain: 0, publicKey: key.publicKey }));
+        // Prepare transfer
+        let seqno = await contract.getSeqno();
+        let transfer = contract.createTransfer({
+            seqno,
+            secretKey: key.secretKey,
+            message: (0, core_1.internal)({
+                to: 'kQD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgtwt',
+                value: '0.1',
+                body: 'Hello, world!'
+            })
+        });
+        // Perform transfer
+        await contract.send(transfer);
+    });
+});

package/dist/wallets/WalletContractV1R3.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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";
+export declare class WalletContractV1R3 implements Contract {
+    static create(args: {
+        workchain: number;
+        publicKey: Buffer;
+    }): WalletContractV1R3;
+    readonly workchain: number;
+    readonly publicKey: Buffer;
+    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>;
+    /**
+     * 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;
+}