@ton-wallet/create 14.0.1 → 14.0.3

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

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@ton/core");
+const WalletV5BetaActions_1 = require("./WalletV5BetaActions");
+const mockMessageRelaxed1 = {
+    info: {
+        type: 'external-out',
+        createdLt: 0n,
+        createdAt: 0,
+        dest: null,
+        src: null
+    },
+    body: (0, core_1.beginCell)().storeUint(0, 8).endCell(),
+    init: null
+};
+const mockAddress = core_1.Address.parseRaw('0:' + '1'.repeat(64));
+describe('Wallet V5Beta actions', () => {
+    const outActionSetIsPublicKeyEnabledTag = 0x20cbb95a;
+    const outActionAddExtensionTag = 0x1c40db9f;
+    const outActionRemoveExtensionTag = 0x5eaef4a4;
+    const outActionSendMsgTag = 0x0ec3c86d;
+    it('Should serialise setIsPublicKeyEnabled action with true flag', () => {
+        const action = (0, WalletV5BetaActions_1.storeOutActionExtendedV5Beta)({
+            type: 'setIsPublicKeyEnabled',
+            isEnabled: true
+        });
+        const actual = (0, core_1.beginCell)().store(action).endCell();
+        const expected = (0, core_1.beginCell)()
+            .storeUint(outActionSetIsPublicKeyEnabledTag, 32)
+            .storeBit(1)
+            .endCell();
+        expect(expected.equals(actual)).toBeTruthy();
+    });
+    it('Should serialise setIsPublicKeyEnabled action with false flag', () => {
+        const action = (0, WalletV5BetaActions_1.storeOutActionExtendedV5Beta)({
+            type: 'setIsPublicKeyEnabled',
+            isEnabled: false
+        });
+        const actual = (0, core_1.beginCell)().store(action).endCell();
+        const expected = (0, core_1.beginCell)()
+            .storeUint(outActionSetIsPublicKeyEnabledTag, 32)
+            .storeBit(0)
+            .endCell();
+        expect(expected.equals(actual)).toBeTruthy();
+    });
+    it('Should serialise add extension action', () => {
+        const action = (0, WalletV5BetaActions_1.storeOutActionExtendedV5Beta)({
+            type: 'addExtension',
+            address: mockAddress
+        });
+        const actual = (0, core_1.beginCell)().store(action).endCell();
+        const expected = (0, core_1.beginCell)()
+            .storeUint(outActionAddExtensionTag, 32)
+            .storeAddress(mockAddress)
+            .endCell();
+        expect(expected.equals(actual)).toBeTruthy();
+    });
+    it('Should serialise remove extension action', () => {
+        const action = (0, WalletV5BetaActions_1.storeOutActionExtendedV5Beta)({
+            type: 'removeExtension',
+            address: mockAddress
+        });
+        const actual = (0, core_1.beginCell)().store(action).endCell();
+        const expected = (0, core_1.beginCell)()
+            .storeUint(outActionRemoveExtensionTag, 32)
+            .storeAddress(mockAddress)
+            .endCell();
+        expect(expected.equals(actual)).toBeTruthy();
+    });
+    it('Should serialize extended out list', () => {
+        const sendMode1 = core_1.SendMode.PAY_GAS_SEPARATELY;
+        const isPublicKeyEnabled = false;
+        const actions = [
+            {
+                type: 'addExtension',
+                address: mockAddress
+            },
+            {
+                type: 'setIsPublicKeyEnabled',
+                isEnabled: isPublicKeyEnabled
+            },
+            {
+                type: 'sendMsg',
+                mode: sendMode1,
+                outMsg: mockMessageRelaxed1
+            }
+        ];
+        const actual = (0, core_1.beginCell)().store((0, WalletV5BetaActions_1.storeOutListExtendedV5Beta)(actions)).endCell();
+        const expected = (0, core_1.beginCell)()
+            .storeUint(1, 1)
+            .storeUint(outActionAddExtensionTag, 32)
+            .storeAddress(mockAddress)
+            .storeRef((0, core_1.beginCell)()
+            .storeUint(1, 1)
+            .storeUint(outActionSetIsPublicKeyEnabledTag, 32)
+            .storeBit(isPublicKeyEnabled ? 1 : 0)
+            .storeRef((0, core_1.beginCell)()
+            .storeUint(0, 1)
+            .storeRef((0, core_1.beginCell)()
+            .storeRef((0, core_1.beginCell)().endCell())
+            .storeUint(outActionSendMsgTag, 32)
+            .storeUint(sendMode1, 8)
+            .storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(mockMessageRelaxed1)).endCell())
+            .endCell())
+            .endCell())
+            .endCell())
+            .endCell();
+        expect(actual.equals(expected)).toBeTruthy();
+    });
+    it('Should deserialize extended out list', () => {
+        const sendMode1 = core_1.SendMode.PAY_GAS_SEPARATELY;
+        const isPublicKeyEnabled = true;
+        const expected = [
+            {
+                type: 'addExtension',
+                address: mockAddress
+            },
+            {
+                type: 'setIsPublicKeyEnabled',
+                isEnabled: isPublicKeyEnabled
+            },
+            {
+                type: 'sendMsg',
+                mode: sendMode1,
+                outMsg: mockMessageRelaxed1
+            }
+        ];
+        const serialized = (0, core_1.beginCell)()
+            .storeUint(1, 1)
+            .storeUint(outActionAddExtensionTag, 32)
+            .storeAddress(mockAddress)
+            .storeRef((0, core_1.beginCell)()
+            .storeUint(1, 1)
+            .storeUint(outActionSetIsPublicKeyEnabledTag, 32)
+            .storeBit(isPublicKeyEnabled ? 1 : 0)
+            .storeRef((0, core_1.beginCell)()
+            .storeUint(0, 1)
+            .storeRef((0, core_1.beginCell)()
+            .storeRef((0, core_1.beginCell)().endCell())
+            .storeUint(outActionSendMsgTag, 32)
+            .storeUint(sendMode1, 8)
+            .storeRef((0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(mockMessageRelaxed1)).endCell())
+            .endCell())
+            .endCell())
+            .endCell())
+            .endCell();
+        const actual = (0, WalletV5BetaActions_1.loadOutListExtendedV5Beta)(serialized.beginParse());
+        expect(expected.length).toEqual(actual.length);
+        expected.forEach((item1, index) => {
+            const item2 = actual[index];
+            expect(item1.type).toEqual(item2.type);
+            if (item1.type === 'sendMsg' && item2.type === 'sendMsg') {
+                expect(item1.mode).toEqual(item2.mode);
+                expect(item1.outMsg.body.equals(item2.outMsg.body)).toBeTruthy();
+                expect(item1.outMsg.info).toEqual(item2.outMsg.info);
+                expect(item1.outMsg.init).toEqual(item2.outMsg.init);
+            }
+            if (item1.type === 'addExtension' && item2.type === 'addExtension') {
+                expect(item1.address.equals(item2.address)).toBeTruthy();
+            }
+            if (item1.type === 'setIsPublicKeyEnabled' && item2.type === 'setIsPublicKeyEnabled') {
+                expect(item1.isEnabled).toEqual(item2.isEnabled);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Builder, Slice } from '@ton/core';
+export interface WalletIdV5Beta {
+    readonly walletVersion: 'v5';
+    /**
+     * -239 is mainnet, -3 is testnet
+     */
+    readonly networkGlobalId: number;
+    readonly workchain: number;
+    readonly subwalletNumber: number;
+}
+export declare function loadWalletIdV5Beta(value: bigint | Buffer | Slice): WalletIdV5Beta;
+export declare function storeWalletIdV5Beta(walletId: WalletIdV5Beta): (builder: Builder) => void;

package/dist/wallets/v5beta/WalletV5BetaWalletId.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeWalletIdV5Beta = exports.loadWalletIdV5Beta = void 0;
+const core_1 = require("@ton/core");
+const walletV5BetaVersionsSerialisation = {
+    v5: 0
+};
+function loadWalletIdV5Beta(value) {
+    const bitReader = new core_1.BitReader(new core_1.BitString(typeof value === 'bigint' ?
+        Buffer.from(value.toString(16), 'hex') :
+        value instanceof core_1.Slice ? value.loadBuffer(10) : value, 0, 80));
+    const networkGlobalId = bitReader.loadInt(32);
+    const workchain = bitReader.loadInt(8);
+    const walletVersionRaw = bitReader.loadUint(8);
+    const subwalletNumber = bitReader.loadUint(32);
+    const walletVersion = Object.entries(walletV5BetaVersionsSerialisation).find(([_, value]) => value === walletVersionRaw)?.[0];
+    if (walletVersion === undefined) {
+        throw new Error(`Can't deserialize walletId: unknown wallet version ${walletVersionRaw}`);
+    }
+    return { networkGlobalId, workchain, walletVersion, subwalletNumber };
+}
+exports.loadWalletIdV5Beta = loadWalletIdV5Beta;
+function storeWalletIdV5Beta(walletId) {
+    return (builder) => {
+        builder.storeInt(walletId.networkGlobalId, 32);
+        builder.storeInt(walletId.workchain, 8);
+        builder.storeUint(walletV5BetaVersionsSerialisation[walletId.walletVersion], 8);
+        builder.storeUint(walletId.subwalletNumber, 32);
+    };
+}
+exports.storeWalletIdV5Beta = storeWalletIdV5Beta;

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

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