@ton/ton 13.5.1 → 13.8.0

package/dist/utils/fees.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeMessageForwardFees = exports.computeExternalMessageFees = exports.computeGasPrices = exports.computeFwdFees = exports.computeStorageFees = void 0;
+const core_1 = require("@ton/core");
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L425
+//
+function computeStorageFees(data) {
+    const { lastPaid, now, storagePrices, storageStat, special, masterchain } = data;
+    if (now <= lastPaid || storagePrices.length === 0 || now < storagePrices[0].utime_since || special) {
+        return BigInt(0);
+    }
+    let upto = Math.max(lastPaid, storagePrices[0].utime_since);
+    let total = BigInt(0);
+    for (let i = 0; i < storagePrices.length && upto < now; i++) {
+        let valid_until = (i < storagePrices.length - 1 ? Math.min(now, storagePrices[i + 1].utime_since) : now);
+        let payment = BigInt(0);
+        if (upto < valid_until) {
+            let delta = valid_until - upto;
+            payment += (BigInt(storageStat.cells) * (masterchain ? storagePrices[i].mc_cell_price_ps : storagePrices[i].cell_price_ps));
+            payment += (BigInt(storageStat.bits) * (masterchain ? storagePrices[i].mc_bit_price_ps : storagePrices[i].bit_price_ps));
+            payment = payment * BigInt(delta);
+        }
+        upto = valid_until;
+        total += payment;
+    }
+    return shr16ceil(total);
+}
+exports.computeStorageFees = computeStorageFees;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L1218
+//
+function computeFwdFees(msgPrices, cells, bits) {
+    return msgPrices.lumpPrice + (shr16ceil(msgPrices.bitPrice * bits + (msgPrices.cellPrice * cells)));
+}
+exports.computeFwdFees = computeFwdFees;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L761
+//
+function computeGasPrices(gasUsed, prices) {
+    if (gasUsed <= prices.flatLimit) {
+        return prices.flatPrice;
+    }
+    else {
+        //  td::rshift(gas_price256 * (gas_used - cfg.flat_gas_limit), 16, 1) + cfg.flat_gas_price
+        return prices.flatPrice + ((prices.price * (gasUsed - prices.flatLimit)) >> 16n);
+    }
+}
+exports.computeGasPrices = computeGasPrices;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L530
+//
+function computeExternalMessageFees(msgPrices, cell) {
+    // Collect stats
+    let storageStats = collectCellStats(cell);
+    storageStats.bits -= cell.bits.length;
+    storageStats.cells -= 1;
+    return computeFwdFees(msgPrices, BigInt(storageStats.cells), BigInt(storageStats.bits));
+}
+exports.computeExternalMessageFees = computeExternalMessageFees;
+function computeMessageForwardFees(msgPrices, cell) {
+    let msg = (0, core_1.loadMessageRelaxed)(cell.beginParse());
+    let storageStats = { bits: 0, cells: 0 };
+    // Init
+    if (msg.init) {
+        const rawBuilder = new core_1.Cell().asBuilder();
+        (0, core_1.storeStateInit)(msg.init)(rawBuilder);
+        const raw = rawBuilder.endCell();
+        let c = collectCellStats(raw);
+        c.bits -= raw.bits.length;
+        c.cells -= 1;
+        storageStats.bits += c.bits;
+        storageStats.cells += c.cells;
+    }
+    // Body
+    let bc = collectCellStats(msg.body);
+    bc.bits -= msg.body.bits.length;
+    bc.cells -= 1;
+    storageStats.bits += bc.bits;
+    storageStats.cells += bc.cells;
+    // NOTE: Extra currencies are ignored for now
+    let fees = computeFwdFees(msgPrices, BigInt(storageStats.cells), BigInt(storageStats.bits));
+    let res = (fees * BigInt(msgPrices.firstFrac)) >> 16n;
+    let remaining = fees - res;
+    return { fees: res, remaining };
+}
+exports.computeMessageForwardFees = computeMessageForwardFees;
+function collectCellStats(cell) {
+    let bits = cell.bits.length;
+    let cells = 1;
+    for (let ref of cell.refs) {
+        let r = collectCellStats(ref);
+        cells += r.cells;
+        bits += r.bits;
+    }
+    return { bits, cells };
+}
+function shr16ceil(src) {
+    let rem = src % 65536n;
+    let res = src >> 16n;
+    if (rem !== 0n) {
+        res += 1n;
+    }
+    return res;
+}

package/dist/utils/fees.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/fees.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fees_1 = require("./fees");
+const core_1 = require("@ton/core");
+const WalletContractV4_1 = require("../wallets/WalletContractV4");
+describe('estimateFees', () => {
+    it('should estimate fees correctly', () => {
+        const config = {
+            storage: [{ utime_since: 0, bit_price_ps: BigInt(1), cell_price_ps: BigInt(500), mc_bit_price_ps: BigInt(1000), mc_cell_price_ps: BigInt(500000) }],
+            workchain: {
+                gas: { flatLimit: BigInt(100), flatGasPrice: BigInt(100000), price: BigInt(65536000) },
+                message: { lumpPrice: BigInt(1000000), bitPrice: BigInt(65536000), cellPrice: BigInt(6553600000), firstFrac: 21845 }
+            },
+        };
+        const storageStats = [{
+                lastPaid: 1696792239, duePayment: null,
+                used: { bits: 6888, cells: 14, publicCells: 0 }
+            }];
+        const gasUsageByOutMsgs = { 1: 3308, 2: 3950, 3: 4592, 4: 5234 };
+        const contract = WalletContractV4_1.WalletContractV4.create({ workchain: 0, publicKey: Buffer.from('MUP3GpbKCQu64L4PIU0QprZxmSUygHcaYKuo2tZYA1c=', 'base64') });
+        const body = (0, core_1.comment)('Test message fees estimation');
+        const testAddress = core_1.Address.parse('EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N');
+        // Create transfer
+        let intMessage = (0, core_1.internal)({
+            to: testAddress,
+            value: 1400000000n,
+            bounce: true,
+            body,
+        });
+        let transfer = contract.createTransfer({
+            seqno: 14,
+            secretKey: Buffer.alloc(64),
+            sendMode: core_1.SendMode.IGNORE_ERRORS | core_1.SendMode.PAY_GAS_SEPARATELY,
+            messages: [intMessage]
+        });
+        const externalMessage = (0, core_1.external)({
+            to: contract.address,
+            body: transfer,
+            init: null
+        });
+        let inMsg = new core_1.Cell().asBuilder();
+        (0, core_1.storeMessage)(externalMessage)(inMsg);
+        let outMsg = new core_1.Cell().asBuilder();
+        (0, core_1.storeMessageRelaxed)(intMessage)(outMsg);
+        // Storage fees
+        let storageFees = BigInt(0);
+        for (let storageStat of storageStats) {
+            if (storageStat) {
+                const computed = (0, fees_1.computeStorageFees)({
+                    lastPaid: storageStat.lastPaid,
+                    masterchain: false,
+                    now: 1697445678,
+                    special: false,
+                    storagePrices: config.storage,
+                    storageStat: {
+                        bits: storageStat.used.bits,
+                        cells: storageStat.used.cells,
+                        publicCells: storageStat.used.publicCells
+                    }
+                });
+                storageFees = storageFees + computed;
+            }
+        }
+        expect((0, core_1.fromNano)(storageFees)).toBe('0.000138473');
+        // Calculate import fees
+        let importFees = (0, fees_1.computeExternalMessageFees)(config.workchain.message, inMsg.endCell());
+        expect((0, core_1.fromNano)(importFees)).toBe('0.001772');
+        // Any transaction use this amount of gas
+        const gasUsed = gasUsageByOutMsgs[1];
+        let gasFees = (0, fees_1.computeGasPrices)(BigInt(gasUsed), { flatLimit: config.workchain.gas.flatLimit, flatPrice: config.workchain.gas.flatGasPrice, price: config.workchain.gas.price });
+        expect((0, core_1.fromNano)(gasFees)).toBe('0.003308');
+        // Total
+        let total = BigInt(0);
+        total += storageFees;
+        total += importFees;
+        total += gasFees;
+        // Forward fees
+        let fwdFees = (0, fees_1.computeMessageForwardFees)(config.workchain.message, outMsg.endCell());
+        expect((0, core_1.fromNano)(fwdFees.fees)).toBe('0.000333328');
+        total += fwdFees.fees;
+        expect((0, core_1.fromNano)(total)).toBe('0.005551801');
+    });
+});

package/dist/wallets/WalletContractV5.d.ts

@@ -0,0 +1,111 @@
+/**
+ * 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, OutAction, Sender, SendMode } from "@ton/core";
+import { Maybe } from "../utils/maybe";
+import { OutActionExtended, WalletId } from "./WalletV5Utils";
+export declare type Wallet5BasicSendArgs = {
+    seqno: number;
+    sendMode?: Maybe<SendMode>;
+    timeout?: Maybe<number>;
+};
+export declare type SingedAuthWallet5SendArgs = Wallet5BasicSendArgs & {
+    secretKey: Buffer;
+};
+export declare type ExtensionAuthWallet5SendArgs = Wallet5BasicSendArgs & {};
+export declare type Wallet5SendArgs = SingedAuthWallet5SendArgs | ExtensionAuthWallet5SendArgs;
+export declare class WalletContractV5 implements Contract {
+    readonly walletId: WalletId;
+    readonly publicKey: Buffer;
+    static opCodes: {
+        auth_extension: number;
+        auth_signed: number;
+    };
+    static create(args: {
+        walletId?: Partial<WalletId>;
+        publicKey: Buffer;
+    }): WalletContractV5;
+    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[]>;
+    /**
+     * Send signed transfer
+     */
+    send(provider: ContractProvider, message: Cell): Promise<void>;
+    /**
+     * Sign and send transfer
+     */
+    sendTransfer(provider: ContractProvider, args: Wallet5SendArgs & {
+        messages: MessageRelaxed[];
+    }): Promise<void>;
+    /**
+     * Sign and send add extension request
+     */
+    sendAddExtension(provider: ContractProvider, args: Wallet5SendArgs & {
+        extensionAddress: Address;
+    }): Promise<void>;
+    /**
+     * Sign and send remove extension request
+     */
+    sendRemoveExtension(provider: ContractProvider, args: Wallet5SendArgs & {
+        extensionAddress: Address;
+    }): Promise<void>;
+    /**
+     * Sign and send request
+     */
+    sendRequest(provider: ContractProvider, args: Wallet5SendArgs & {
+        actions: (OutAction | OutActionExtended)[];
+    }): Promise<void>;
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args: Wallet5SendArgs & {
+        messages: MessageRelaxed[];
+    }): Cell;
+    /**
+     * Create signed add extension request
+     */
+    createAddExtension(args: Wallet5SendArgs & {
+        extensionAddress: Address;
+    }): Cell;
+    /**
+     * Create signed remove extension request
+     */
+    createRemoveExtension(args: Wallet5SendArgs & {
+        extensionAddress: Address;
+    }): Cell;
+    /**
+     * Create signed request
+     */
+    createRequest(args: Wallet5SendArgs & {
+        actions: (OutAction | OutActionExtended)[];
+    }): Cell;
+    /**
+     * Create sender
+     */
+    sender(provider: ContractProvider, secretKey: Buffer): Sender;
+}

package/dist/wallets/WalletContractV5.js

@@ -0,0 +1,197 @@
+"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.WalletContractV5 = void 0;
+const core_1 = require("@ton/core");
+const createWalletTransfer_1 = require("./signing/createWalletTransfer");
+const WalletV5Utils_1 = require("./WalletV5Utils");
+class WalletContractV5 {
+    constructor(walletId, publicKey) {
+        this.walletId = walletId;
+        this.publicKey = publicKey;
+        this.walletId = walletId;
+        // Build initial code and data
+        let code = core_1.Cell.fromBoc(Buffer.from('te6cckEBAQEAIwAIQgLND3fEdsoVqej99mmdJbaOAOcmH9K3vkNG64R7FPAsl9kimVw=', 'base64'))[0];
+        let data = (0, core_1.beginCell)()
+            .storeUint(0, 32) // Seqno
+            .store((0, WalletV5Utils_1.storeWalletId)(this.walletId))
+            .storeBuffer(this.publicKey)
+            .storeBit(0) // Empty plugins dict
+            .endCell();
+        this.init = { code, data };
+        this.address = (0, core_1.contractAddress)(this.walletId.workChain, { code, data });
+    }
+    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 WalletContractV5(walletId, 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;
+        }
+    }
+    /**
+     * 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)}`);
+        });
+    }
+    /**
+     * Send signed transfer
+     */
+    async send(provider, message) {
+        await provider.external(message);
+    }
+    /**
+     * Sign and send transfer
+     */
+    async sendTransfer(provider, args) {
+        const transfer = this.createTransfer(args);
+        await this.send(provider, transfer);
+    }
+    /**
+     * Sign and send add extension request
+     */
+    async sendAddExtension(provider, args) {
+        const request = this.createAddExtension(args);
+        await this.send(provider, request);
+    }
+    /**
+     * Sign and send remove extension request
+     */
+    async sendRemoveExtension(provider, args) {
+        const request = this.createRemoveExtension(args);
+        await this.send(provider, request);
+    }
+    /**
+     * Sign and send request
+     */
+    async sendRequest(provider, args) {
+        const request = this.createRequest(args);
+        await this.send(provider, request);
+    }
+    /**
+     * Create signed transfer
+     */
+    createTransfer(args) {
+        const { messages, ...rest } = args;
+        const sendMode = args.sendMode ?? core_1.SendMode.PAY_GAS_SEPARATELY;
+        const actions = messages.map(message => ({ type: 'sendMsg', mode: sendMode, outMsg: message }));
+        return this.createRequest({
+            ...rest,
+            actions
+        });
+    }
+    /**
+     * Create signed add extension request
+     */
+    createAddExtension(args) {
+        const { extensionAddress, ...rest } = args;
+        return this.createRequest({
+            actions: [{
+                    type: 'addExtension',
+                    address: extensionAddress
+                }],
+            ...rest
+        });
+    }
+    /**
+     * Create signed remove extension request
+     */
+    createRemoveExtension(args) {
+        const { extensionAddress, ...rest } = args;
+        return this.createRequest({
+            actions: [{
+                    type: 'removeExtension',
+                    address: extensionAddress
+                }],
+            ...rest
+        });
+    }
+    /**
+     * Create signed request
+     */
+    createRequest(args) {
+        return (0, createWalletTransfer_1.createWalletTransferV5)({
+            ...args,
+            sendMode: args.sendMode ?? core_1.SendMode.PAY_GAS_SEPARATELY,
+            walletId: (0, WalletV5Utils_1.storeWalletId)(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,
+                    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.WalletContractV5 = WalletContractV5;
+WalletContractV5.opCodes = {
+    auth_extension: 0x6578746e,
+    auth_signed: 0x7369676e
+};

package/dist/wallets/WalletContractV5.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/WalletContractV5.spec.js

@@ -0,0 +1,151 @@
+"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 core_1 = require("@ton/core");
+const WalletContractV5_1 = require("./WalletContractV5");
+const createTestClient_1 = require("../utils/createTestClient");
+const getExtensionsArray = async (wallet) => {
+    try {
+        return await wallet.getExtensionsArray();
+    }
+    catch (e) {
+        // Handle toncenter bug. Toncenter incorrectly returns 'list' in the stack in case of empty extensions dict
+        if (e instanceof Error && e.message === 'Unsupported stack item type: list') {
+            return [];
+        }
+        throw e;
+    }
+};
+describe('WalletContractV5', () => {
+    let client;
+    let walletKey;
+    let wallet;
+    beforeEach(() => {
+        client = (0, createTestClient_1.createTestClient)();
+        walletKey = (0, randomTestKey_1.randomTestKey)('v5-treasure');
+        wallet = client.open(WalletContractV5_1.WalletContractV5.create({ walletId: { networkGlobalId: -3 }, publicKey: walletKey.publicKey }));
+    });
+    it('should has balance and correct address', async () => {
+        const balance = await wallet.getBalance();
+        expect(wallet.address.equals(core_1.Address.parse('EQDv2B0jPmJZ1j-ne3Ko64eGqfYZRHGQbfSE5pUWVvUdQmDH'))).toBeTruthy();
+        expect(balance > 0n).toBe(true);
+    });
+    it('should perform single transfer', async () => {
+        const seqno = await wallet.getSeqno();
+        const transfer = wallet.createTransfer({
+            seqno,
+            secretKey: walletKey.secretKey,
+            messages: [(0, core_1.internal)({
+                    to: 'EQDQ0PRYSWmW-v6LVHNYq5Uelpr5f7Ct7awG7Lao2HImrCzn',
+                    value: '0.01',
+                    body: 'Hello world single transfer!'
+                })]
+        });
+        await wallet.send(transfer);
+    });
+    it('should perform double transfer', async () => {
+        const seqno = await wallet.getSeqno();
+        const transfer = wallet.createTransfer({
+            seqno,
+            secretKey: walletKey.secretKey,
+            messages: [(0, core_1.internal)({
+                    to: 'EQDQ0PRYSWmW-v6LVHNYq5Uelpr5f7Ct7awG7Lao2HImrCzn',
+                    value: '0.01',
+                    body: 'Hello world to extension'
+                }), (0, core_1.internal)({
+                    to: 'EQAtHiE_vEyAogU1rHcz3uzp64h-yqeFJ2S2ChkKNwygLMk3',
+                    value: '0.02',
+                    body: 'Hello world to relayer'
+                })]
+        });
+        await wallet.send(transfer);
+    });
+    it('should add extension', async () => {
+        const extensionKey = (0, randomTestKey_1.randomTestKey)('v5-treasure-extension');
+        const extensionContract = client.open(WalletContractV5_1.WalletContractV5.create({ walletId: { workChain: 0, networkGlobalId: -3 }, publicKey: extensionKey.publicKey }));
+        const seqno = await wallet.getSeqno();
+        const extensions = await getExtensionsArray(wallet);
+        const extensionAlreadyAdded = extensions.some(address => address.equals(extensionContract.address));
+        if (!extensionAlreadyAdded) {
+            await wallet.sendAddExtension({
+                seqno,
+                secretKey: walletKey.secretKey,
+                extensionAddress: extensionContract.address
+            });
+            const waitUntilExtensionAdded = async (attempt = 0) => {
+                if (attempt >= 10) {
+                    throw new Error('Extension was not added in 10 blocks');
+                }
+                const extensions = await getExtensionsArray(wallet);
+                const extensionAdded = extensions.some(address => address.equals(extensionContract.address));
+                if (extensionAdded) {
+                    return;
+                }
+                await new Promise(r => setTimeout(r, 1500));
+                return waitUntilExtensionAdded(attempt + 1);
+            };
+            await waitUntilExtensionAdded();
+        }
+        const extensionsSeqno = await extensionContract.getSeqno();
+        await extensionContract.sendTransfer({
+            seqno: extensionsSeqno,
+            secretKey: extensionKey.secretKey,
+            messages: [(0, core_1.internal)({
+                    to: wallet.address,
+                    value: '0.1',
+                    body: wallet.createTransfer({
+                        seqno: seqno + 1,
+                        messages: [(0, core_1.internal)({
+                                to: 'kQD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgtwt',
+                                value: '0.03',
+                                body: 'Hello world from plugin'
+                            })]
+                    })
+                })]
+        });
+    }, 60000);
+    it('should remove extension', async () => {
+        const extensionKey = (0, randomTestKey_1.randomTestKey)('v5-treasure-extension');
+        const extensionContract = client.open(WalletContractV5_1.WalletContractV5.create({ walletId: { workChain: 0, networkGlobalId: -3 }, publicKey: extensionKey.publicKey }));
+        const seqno = await wallet.getSeqno();
+        const extensions = await getExtensionsArray(wallet);
+        const extensionAlreadyAdded = extensions.some(address => address.equals(extensionContract.address));
+        if (extensionAlreadyAdded) {
+            await wallet.sendRemoveExtension({
+                seqno,
+                secretKey: walletKey.secretKey,
+                extensionAddress: extensionContract.address
+            });
+        }
+    });
+    it('should send internal transfer via relayer', async () => {
+        const relaerKey = (0, randomTestKey_1.randomTestKey)('v5-treasure-relayer');
+        const relayerContract = client.open(WalletContractV5_1.WalletContractV5.create({ walletId: { workChain: 0, networkGlobalId: -3 }, publicKey: relaerKey.publicKey }));
+        const seqno = await wallet.getSeqno();
+        const relayerSeqno = await relayerContract.getSeqno();
+        await relayerContract.sendTransfer({
+            seqno: relayerSeqno,
+            secretKey: relaerKey.secretKey,
+            messages: [(0, core_1.internal)({
+                    to: wallet.address,
+                    value: '0.1',
+                    body: wallet.createTransfer({
+                        seqno: seqno,
+                        secretKey: walletKey.secretKey,
+                        messages: [(0, core_1.internal)({
+                                to: 'kQD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgtwt',
+                                value: '0.04',
+                                body: 'Hello world from relayer'
+                            })]
+                    })
+                })]
+        });
+    });
+});

package/dist/wallets/WalletV5Utils.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { Address, Builder, Cell, OutAction, Slice } from '@ton/core';
+export interface OutActionSetData {
+    type: 'setData';
+    newData: Cell;
+}
+export interface OutActionAddExtension {
+    type: 'addExtension';
+    address: Address;
+}
+export interface OutActionRemoveExtension {
+    type: 'removeExtension';
+    address: Address;
+}
+export declare type OutActionExtended = OutActionSetData | OutActionAddExtension | OutActionRemoveExtension;
+export declare function storeOutActionExtended(action: OutActionExtended): (builder: Builder) => void;
+export declare function loadOutActionExtended(slice: Slice): OutActionExtended;
+export declare function isOutActionExtended(action: OutAction | OutActionExtended): action is OutActionExtended;
+export declare function storeOutListExtended(actions: (OutActionExtended | OutAction)[]): (builder: Builder) => void;
+export declare function loadOutListExtended(slice: Slice): (OutActionExtended | OutAction)[];
+export interface WalletId {
+    readonly walletVersion: 'v5';
+    /**
+     * -239 is mainnet, -3 is testnet
+     */
+    readonly networkGlobalId: number;
+    readonly workChain: number;
+    readonly subwalletNumber: number;
+}
+export declare function loadWalletId(value: bigint | Buffer | Slice): WalletId;
+export declare function storeWalletId(walletId: WalletId): (builder: Builder) => void;