@ton/ton 13.11.2 → 15.0.0

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 {};

package/dist/wallets/v5beta/WalletContractV5Beta.spec.js

@@ -0,0 +1,298 @@
+"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 WalletContractV5Beta_1 = require("./WalletContractV5Beta");
+const crypto_1 = require("@ton/crypto");
+const createTestClient4_1 = require("../../utils/createTestClient4");
+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 && typeof e === 'object' && 'message' in e && e.message === 'Unsupported stack item type: list') {
+            return [];
+        }
+        throw e;
+    }
+};
+describe('WalletContractV5Beta', () => {
+    let client;
+    let walletKey;
+    let wallet;
+    beforeEach(() => {
+        client = (0, createTestClient4_1.createTestClient4)();
+        walletKey = (0, randomTestKey_1.randomTestKey)('v5-treasure-1');
+        wallet = client.open(WalletContractV5Beta_1.WalletContractV5Beta.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('EQAb3OyXDQyjOGf3HOXPXELTF8dhZP0onqMPz6fNQbleRqtY'))).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,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQB-2r0kM28L4lmq-4V8ppQGcnO1tXC7FZmbnDzWZVBkp6jE',
+                    value: '0.01',
+                    body: 'Hello world single transfer!'
+                })]
+        });
+        await wallet.send(transfer);
+    });
+    it('should perform single transfer with async signing', async () => {
+        const seqno = await wallet.getSeqno();
+        const signer = (payload) => new Promise(r => setTimeout(() => {
+            const signature = (0, crypto_1.sign)(payload.hash(), walletKey.secretKey);
+            r(signature);
+        }, 100));
+        const transfer = await wallet.createTransfer({
+            seqno,
+            signer,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQB-2r0kM28L4lmq-4V8ppQGcnO1tXC7FZmbnDzWZVBkp6jE',
+                    value: '0.01',
+                    body: 'Hello world single transfer signed async!'
+                })]
+        });
+        await wallet.send(transfer);
+    });
+    it('should perform double transfer', async () => {
+        const seqno = await wallet.getSeqno();
+        const transfer = wallet.createTransfer({
+            seqno,
+            secretKey: walletKey.secretKey,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQB-2r0kM28L4lmq-4V8ppQGcnO1tXC7FZmbnDzWZVBkp6jE',
+                    value: '0.01',
+                    body: 'Hello world to extension'
+                }), (0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQDUyIkKoOR5iZ1Gz60JwKc7wPr3LcdHxOJpVDb9jAKY_pfk',
+                    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(WalletContractV5Beta_1.WalletContractV5Beta.create({ walletId: { workchain: 0, networkGlobalId: -3 }, publicKey: extensionKey.publicKey }));
+        let 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 >= 20) {
+                    throw new Error('Extension was not added in 20 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();
+        }
+        seqno = await wallet.getSeqno();
+        const extensionsSeqno = await extensionContract.getSeqno();
+        await extensionContract.sendTransfer({
+            seqno: extensionsSeqno,
+            secretKey: extensionKey.secretKey,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    to: wallet.address,
+                    value: '0.02',
+                    body: wallet.createTransfer({
+                        seqno: seqno,
+                        authType: 'extension',
+                        sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+                        messages: [(0, core_1.internal)({
+                                bounce: false,
+                                to: '0QD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgoHo',
+                                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(WalletContractV5Beta_1.WalletContractV5Beta.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(WalletContractV5Beta_1.WalletContractV5Beta.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,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    to: wallet.address,
+                    value: '0.03',
+                    body: wallet.createTransfer({
+                        seqno: seqno,
+                        secretKey: walletKey.secretKey,
+                        authType: 'internal',
+                        sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+                        messages: [(0, core_1.internal)({
+                                bounce: false,
+                                to: '0QD2NmD_lH5f5u1Kj3KfGyTvhZSX0Eg6qp2a5IQUKXxOG4so',
+                                value: '0.04',
+                                body: 'Hello world from relayer'
+                            })]
+                    })
+                })]
+        });
+    });
+    it('should disable secret key auth, send extension-auth tx, and enable it again', async () => {
+        /* firstly add an extension that will take the control over the wallet */
+        const extensionKey = (0, randomTestKey_1.randomTestKey)('v5-treasure-extension');
+        const extensionContract = client.open(WalletContractV5Beta_1.WalletContractV5Beta.create({ walletId: { workchain: 0, networkGlobalId: -3 }, publicKey: extensionKey.publicKey }));
+        let 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 >= 20) {
+                    throw new Error('Extension was not added in 20 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();
+        }
+        /* disable secret key auth */
+        seqno = await wallet.getSeqno();
+        const isInitiallyEnabled = await wallet.getIsSecretKeyAuthEnabled();
+        const waitUntilAuthValue = async (target, attempt = 0) => {
+            if (attempt >= 20) {
+                throw new Error('Auth permissions were not changed in 20 blocks');
+            }
+            const isEnabledNow = await wallet.getIsSecretKeyAuthEnabled();
+            if ((target === 'enabled' && isEnabledNow) || (target === 'disabled' && !isEnabledNow)) {
+                return;
+            }
+            await new Promise(r => setTimeout(r, 1500));
+            return waitUntilAuthValue(target, attempt + 1);
+        };
+        if (isInitiallyEnabled) {
+            await wallet.sendActionsBatch({
+                seqno,
+                secretKey: walletKey.secretKey,
+                actions: [
+                    {
+                        type: 'setIsPublicKeyEnabled',
+                        isEnabled: false
+                    }
+                ]
+            });
+            await waitUntilAuthValue('disabled');
+        }
+        /* should fail direct secret-key auth transfer from the wallet */
+        seqno = await wallet.getSeqno();
+        const transfer = wallet.createTransfer({
+            seqno: seqno,
+            secretKey: walletKey.secretKey,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQB-2r0kM28L4lmq-4V8ppQGcnO1tXC7FZmbnDzWZVBkp6jE',
+                    value: '0.01',
+                    body: 'Hello world single transfer that SHOULD FAIL!'
+                })]
+        });
+        await expect(wallet.send(transfer)).rejects.toThrow();
+        /* should perform transfer from the extension and enable auth by secret key  */
+        const extensionsSeqno = await extensionContract.getSeqno();
+        await extensionContract.sendTransfer({
+            seqno: extensionsSeqno,
+            secretKey: extensionKey.secretKey,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    to: wallet.address,
+                    value: '0.03',
+                    body: wallet.createRequest({
+                        seqno,
+                        authType: 'extension',
+                        actions: [
+                            {
+                                type: 'setIsPublicKeyEnabled',
+                                isEnabled: true
+                            },
+                            {
+                                type: "sendMsg",
+                                mode: core_1.SendMode.IGNORE_ERRORS + core_1.SendMode.PAY_GAS_SEPARATELY,
+                                outMsg: (0, core_1.internal)({
+                                    bounce: false,
+                                    to: '0QD6oPnzaaAMRW24R8F0_nlSsJQni0cGHntR027eT9_sgoHo',
+                                    value: '0.03',
+                                    body: 'Hello world from plugin that controls the wallet!'
+                                })
+                            }
+                        ]
+                    })
+                })]
+        });
+        await waitUntilAuthValue('enabled');
+        /* should fail direct secret-key auth transfer from the wallet */
+        await wallet.sendTransfer({
+            seqno: seqno + 1,
+            secretKey: walletKey.secretKey,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            messages: [(0, core_1.internal)({
+                    bounce: false,
+                    to: 'UQB-2r0kM28L4lmq-4V8ppQGcnO1tXC7FZmbnDzWZVBkp6jE',
+                    value: '0.01',
+                    body: 'Hello world single transfer after sk auth enabled!'
+                })]
+        });
+    }, 120000);
+});

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

@@ -0,0 +1,6 @@
+import { Builder, OutActionSendMsg, Slice } from '@ton/core';
+import { OutActionExtended } from "./WalletV5OutActions";
+export declare function storeOutActionExtendedV5Beta(action: OutActionExtended): (builder: Builder) => void;
+export declare function loadOutActionV5BetaExtended(slice: Slice): OutActionExtended;
+export declare function storeOutListExtendedV5Beta(actions: (OutActionExtended | OutActionSendMsg)[]): (builder: Builder) => void;
+export declare function loadOutListExtendedV5Beta(slice: Slice): (OutActionExtended | OutActionSendMsg)[];

package/dist/wallets/v5beta/WalletV5BetaActions.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOutListExtendedV5Beta = exports.storeOutListExtendedV5Beta = exports.loadOutActionV5BetaExtended = exports.storeOutActionExtendedV5Beta = void 0;
+const core_1 = require("@ton/core");
+const WalletV5OutActions_1 = require("./WalletV5OutActions");
+const outActionSetIsPublicKeyEnabledTag = 0x20cbb95a;
+function storeOutActionSetIsPublicKeyEnabled(action) {
+    return (builder) => {
+        builder.storeUint(outActionSetIsPublicKeyEnabledTag, 32).storeUint(action.isEnabled ? 1 : 0, 1);
+    };
+}
+const outActionAddExtensionTag = 0x1c40db9f;
+function storeOutActionAddExtension(action) {
+    return (builder) => {
+        builder.storeUint(outActionAddExtensionTag, 32).storeAddress(action.address);
+    };
+}
+const outActionRemoveExtensionTag = 0x5eaef4a4;
+function storeOutActionRemoveExtension(action) {
+    return (builder) => {
+        builder.storeUint(outActionRemoveExtensionTag, 32).storeAddress(action.address);
+    };
+}
+function storeOutActionExtendedV5Beta(action) {
+    switch (action.type) {
+        case 'setIsPublicKeyEnabled':
+            return storeOutActionSetIsPublicKeyEnabled(action);
+        case 'addExtension':
+            return storeOutActionAddExtension(action);
+        case 'removeExtension':
+            return storeOutActionRemoveExtension(action);
+        default:
+            throw new Error('Unknown action type' + action?.type);
+    }
+}
+exports.storeOutActionExtendedV5Beta = storeOutActionExtendedV5Beta;
+function loadOutActionV5BetaExtended(slice) {
+    const tag = slice.loadUint(32);
+    switch (tag) {
+        case outActionSetIsPublicKeyEnabledTag:
+            return {
+                type: 'setIsPublicKeyEnabled',
+                isEnabled: !!slice.loadUint(1)
+            };
+        case outActionAddExtensionTag:
+            return {
+                type: 'addExtension',
+                address: slice.loadAddress()
+            };
+        case outActionRemoveExtensionTag:
+            return {
+                type: 'removeExtension',
+                address: slice.loadAddress()
+            };
+        default:
+            throw new Error(`Unknown extended out action tag 0x${tag.toString(16)}`);
+    }
+}
+exports.loadOutActionV5BetaExtended = loadOutActionV5BetaExtended;
+function storeOutListExtendedV5Beta(actions) {
+    const [action, ...rest] = actions;
+    if (!action || !(0, WalletV5OutActions_1.isOutActionExtended)(action)) {
+        if (actions.some(WalletV5OutActions_1.isOutActionExtended)) {
+            throw new Error("Can't serialize actions list: all extended actions must be placed before out actions");
+        }
+        return (builder) => {
+            builder
+                .storeUint(0, 1)
+                .storeRef((0, core_1.beginCell)().store((0, core_1.storeOutList)(actions)).endCell());
+        };
+    }
+    return (builder) => {
+        builder.storeUint(1, 1)
+            .store(storeOutActionExtendedV5Beta(action))
+            .storeRef((0, core_1.beginCell)().store(storeOutListExtendedV5Beta(rest)).endCell());
+    };
+}
+exports.storeOutListExtendedV5Beta = storeOutListExtendedV5Beta;
+function loadOutListExtendedV5Beta(slice) {
+    const actions = [];
+    while (slice.loadUint(1)) {
+        const action = loadOutActionV5BetaExtended(slice);
+        actions.push(action);
+        slice = slice.loadRef().beginParse();
+    }
+    const commonAction = (0, core_1.loadOutList)(slice.loadRef().beginParse());
+    if (commonAction.some(i => i.type === 'setCode')) {
+        throw new Error("Can't deserialize actions list: only sendMsg actions are allowed for wallet v5");
+    }
+    return actions.concat(commonAction);
+}
+exports.loadOutListExtendedV5Beta = loadOutListExtendedV5Beta;

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

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