@ton/sandbox 0.11.0

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { defaultConfig, defaultConfigSeqno, } from './config/defaultConfig';
+export { Blockchain, SendMessageResult, BlockchainTransaction, PendingMessage, SandboxContract, ExternalOut, ExternalOutInfo, BlockchainConfig, BlockchainSnapshot, } from './blockchain/Blockchain';
+export { BlockchainContractProvider, SandboxContractProvider, } from './blockchain/BlockchainContractProvider';
+export { BlockchainSender, } from './blockchain/BlockchainSender';
+export { BlockchainStorage, LocalBlockchainStorage, RemoteBlockchainStorage, RemoteBlockchainStorageClient, wrapTonClient4ForRemote, } from './blockchain/BlockchainStorage';
+export { Verbosity, LogsVerbosity, SmartContract, SmartContractTransaction, MessageParams, GetMethodParams, GetMethodResult, createEmptyShardAccount, createShardAccount, GetMethodError, TimeError, SmartContractSnapshot, } from './blockchain/SmartContract';
+export { TickOrTock, } from './executor/Executor';
+export { Event, EventAccountCreated, EventAccountDestroyed, EventMessageSent, } from './event/Event';
+export { Treasury, TreasuryContract, } from './treasury/Treasury';
+export { prettyLogTransaction, prettyLogTransactions, } from './utils/prettyLogTransaction';
+export { printTransactionFees, } from './utils/printTransactionFees';
+export { internal, } from './utils/message';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internal = exports.printTransactionFees = exports.prettyLogTransactions = exports.prettyLogTransaction = exports.TreasuryContract = exports.TimeError = exports.GetMethodError = exports.createShardAccount = exports.createEmptyShardAccount = exports.SmartContract = exports.wrapTonClient4ForRemote = exports.RemoteBlockchainStorage = exports.LocalBlockchainStorage = exports.BlockchainSender = exports.BlockchainContractProvider = exports.Blockchain = exports.defaultConfigSeqno = exports.defaultConfig = void 0;
+var defaultConfig_1 = require("./config/defaultConfig");
+Object.defineProperty(exports, "defaultConfig", { enumerable: true, get: function () { return defaultConfig_1.defaultConfig; } });
+Object.defineProperty(exports, "defaultConfigSeqno", { enumerable: true, get: function () { return defaultConfig_1.defaultConfigSeqno; } });
+var Blockchain_1 = require("./blockchain/Blockchain");
+Object.defineProperty(exports, "Blockchain", { enumerable: true, get: function () { return Blockchain_1.Blockchain; } });
+var BlockchainContractProvider_1 = require("./blockchain/BlockchainContractProvider");
+Object.defineProperty(exports, "BlockchainContractProvider", { enumerable: true, get: function () { return BlockchainContractProvider_1.BlockchainContractProvider; } });
+var BlockchainSender_1 = require("./blockchain/BlockchainSender");
+Object.defineProperty(exports, "BlockchainSender", { enumerable: true, get: function () { return BlockchainSender_1.BlockchainSender; } });
+var BlockchainStorage_1 = require("./blockchain/BlockchainStorage");
+Object.defineProperty(exports, "LocalBlockchainStorage", { enumerable: true, get: function () { return BlockchainStorage_1.LocalBlockchainStorage; } });
+Object.defineProperty(exports, "RemoteBlockchainStorage", { enumerable: true, get: function () { return BlockchainStorage_1.RemoteBlockchainStorage; } });
+Object.defineProperty(exports, "wrapTonClient4ForRemote", { enumerable: true, get: function () { return BlockchainStorage_1.wrapTonClient4ForRemote; } });
+var SmartContract_1 = require("./blockchain/SmartContract");
+Object.defineProperty(exports, "SmartContract", { enumerable: true, get: function () { return SmartContract_1.SmartContract; } });
+Object.defineProperty(exports, "createEmptyShardAccount", { enumerable: true, get: function () { return SmartContract_1.createEmptyShardAccount; } });
+Object.defineProperty(exports, "createShardAccount", { enumerable: true, get: function () { return SmartContract_1.createShardAccount; } });
+Object.defineProperty(exports, "GetMethodError", { enumerable: true, get: function () { return SmartContract_1.GetMethodError; } });
+Object.defineProperty(exports, "TimeError", { enumerable: true, get: function () { return SmartContract_1.TimeError; } });
+var Treasury_1 = require("./treasury/Treasury");
+Object.defineProperty(exports, "TreasuryContract", { enumerable: true, get: function () { return Treasury_1.TreasuryContract; } });
+var prettyLogTransaction_1 = require("./utils/prettyLogTransaction");
+Object.defineProperty(exports, "prettyLogTransaction", { enumerable: true, get: function () { return prettyLogTransaction_1.prettyLogTransaction; } });
+Object.defineProperty(exports, "prettyLogTransactions", { enumerable: true, get: function () { return prettyLogTransaction_1.prettyLogTransactions; } });
+var printTransactionFees_1 = require("./utils/printTransactionFees");
+Object.defineProperty(exports, "printTransactionFees", { enumerable: true, get: function () { return printTransactionFees_1.printTransactionFees; } });
+var message_1 = require("./utils/message");
+Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return message_1.internal; } });

package/dist/treasury/Treasury.d.ts

@@ -0,0 +1,23 @@
+import { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SenderArguments, SendMode } from "ton-core";
+export type Treasury = Sender & {
+    address: Address;
+};
+export declare class TreasuryContract implements Contract {
+    static readonly code: Cell;
+    static create(workchain: number, subwalletId: bigint): TreasuryContract;
+    readonly address: Address;
+    readonly init: {
+        code: Cell;
+        data: Cell;
+    };
+    readonly subwalletId: bigint;
+    constructor(workchain: number, subwalletId: bigint);
+    sendMessages(provider: ContractProvider, messages: MessageRelaxed[], sendMode?: SendMode): Promise<void>;
+    send(provider: ContractProvider, args: SenderArguments): Promise<void>;
+    getSender(provider: ContractProvider): Treasury;
+    getBalance(provider: ContractProvider): Promise<bigint>;
+    createTransfer(args: {
+        messages: MessageRelaxed[];
+        sendMode?: SendMode;
+    }): Cell;
+}

package/dist/treasury/Treasury.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreasuryContract = void 0;
+const ton_core_1 = require("ton-core");
+const DictionaryMessageValue = {
+    serialize(src, builder) {
+        builder.storeUint(src.sendMode, 8);
+        builder.storeRef((0, ton_core_1.beginCell)().store((0, ton_core_1.storeMessageRelaxed)(src.message)));
+    },
+    parse(src) {
+        let sendMode = src.loadUint(8);
+        let message = (0, ton_core_1.loadMessageRelaxed)(src.loadRef().beginParse());
+        return { sendMode, message };
+    },
+};
+function senderArgsToMessageRelaxed(args) {
+    return (0, ton_core_1.internal)({
+        to: args.to,
+        value: args.value,
+        init: args.init,
+        body: args.body,
+        bounce: args.bounce
+    });
+}
+class TreasuryContract {
+    static create(workchain, subwalletId) {
+        return new TreasuryContract(workchain, subwalletId);
+    }
+    constructor(workchain, subwalletId) {
+        const data = (0, ton_core_1.beginCell)()
+            .storeUint(subwalletId, 256)
+            .endCell();
+        this.init = { code: TreasuryContract.code, data };
+        this.address = (0, ton_core_1.contractAddress)(workchain, this.init);
+        this.subwalletId = subwalletId;
+    }
+    async sendMessages(provider, messages, sendMode) {
+        let transfer = this.createTransfer({
+            sendMode: sendMode,
+            messages: messages
+        });
+        await provider.external(transfer);
+    }
+    async send(provider, args) {
+        await this.sendMessages(provider, [senderArgsToMessageRelaxed(args)], args.sendMode ?? undefined);
+    }
+    getSender(provider) {
+        return {
+            address: this.address,
+            send: async (args) => {
+                let transfer = this.createTransfer({
+                    sendMode: args.sendMode ?? undefined,
+                    messages: [senderArgsToMessageRelaxed(args)]
+                });
+                await provider.external(transfer);
+            }
+        };
+    }
+    async getBalance(provider) {
+        return (await provider.getState()).balance;
+    }
+    createTransfer(args) {
+        let sendMode = ton_core_1.SendMode.PAY_GAS_SEPARATELY;
+        if (args.sendMode !== null && args.sendMode !== undefined) {
+            sendMode = args.sendMode;
+        }
+        if (args.messages.length > 255) {
+            throw new Error('Maximum number of messages is 255');
+        }
+        let messages = ton_core_1.Dictionary.empty(ton_core_1.Dictionary.Keys.Int(16), DictionaryMessageValue);
+        let index = 0;
+        for (let m of args.messages) {
+            messages.set(index++, { sendMode, message: m });
+        }
+        return (0, ton_core_1.beginCell)()
+            .storeUint(this.subwalletId, 256)
+            .storeDict(messages)
+            .endCell();
+    }
+}
+exports.TreasuryContract = TreasuryContract;
+TreasuryContract.code = ton_core_1.Cell.fromBase64('te6cckEBBAEARQABFP8A9KQT9LzyyAsBAgEgAwIAWvLT/+1E0NP/0RK68qL0BNH4AH+OFiGAEPR4b6UgmALTB9QwAfsAkTLiAbPmWwAE0jD+omUe');

package/dist/utils/AsyncLock.d.ts

@@ -0,0 +1,6 @@
+export declare class AsyncLock {
+    #private;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    with<T>(fn: () => Promise<T>): Promise<T>;
+}

package/dist/utils/AsyncLock.js

@@ -0,0 +1,48 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AsyncLock_waiters;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLock = void 0;
+function createWaiter() {
+    const w = { promise: undefined, resolve: undefined };
+    w.promise = new Promise((res) => {
+        w.resolve = res;
+    });
+    return w;
+}
+class AsyncLock {
+    constructor() {
+        _AsyncLock_waiters.set(this, []);
+    }
+    async acquire() {
+        const waiters = __classPrivateFieldGet(this, _AsyncLock_waiters, "f").map(w => w.promise);
+        __classPrivateFieldGet(this, _AsyncLock_waiters, "f").push(createWaiter());
+        if (waiters.length > 0) {
+            await Promise.all(waiters);
+        }
+    }
+    async release() {
+        const waiter = __classPrivateFieldGet(this, _AsyncLock_waiters, "f").shift();
+        if (waiter !== undefined) {
+            waiter.resolve();
+        }
+        else {
+            throw new Error('The lock is not locked');
+        }
+    }
+    async with(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            await this.release();
+        }
+    }
+}
+exports.AsyncLock = AsyncLock;
+_AsyncLock_waiters = new WeakMap();

package/dist/utils/base64.d.ts

@@ -0,0 +1 @@
+export declare function base64Decode(sBase64: string): Uint8Array;

package/dist/utils/base64.js

@@ -0,0 +1,42 @@
+"use strict";
+// Credits: https://developer.mozilla.org/en-US/docs/Glossary/Base64#solution_2_–_rewriting_atob_and_btoa_using_typedarrays_and_utf-8
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Decode = void 0;
+function b64ToUint6(nChr) {
+    return nChr > 64 && nChr < 91
+        ? nChr - 65
+        : nChr > 96 && nChr < 123
+            ? nChr - 71
+            : nChr > 47 && nChr < 58
+                ? nChr + 4
+                : nChr === 43
+                    ? 62
+                    : nChr === 47
+                        ? 63
+                        : 0;
+}
+function base64Decode(sBase64) {
+    const sB64Enc = sBase64.replace(/[^A-Za-z0-9+/]/g, "");
+    const nInLen = sB64Enc.length;
+    const nOutLen = (nInLen * 3 + 1) >> 2;
+    const taBytes = new Uint8Array(nOutLen);
+    let nMod3;
+    let nMod4;
+    let nUint24 = 0;
+    let nOutIdx = 0;
+    for (let nInIdx = 0; nInIdx < nInLen; nInIdx++) {
+        nMod4 = nInIdx & 3;
+        nUint24 |= b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << (6 * (3 - nMod4));
+        if (nMod4 === 3 || nInLen - nInIdx === 1) {
+            nMod3 = 0;
+            while (nMod3 < 3 && nOutIdx < nOutLen) {
+                taBytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255;
+                nMod3++;
+                nOutIdx++;
+            }
+            nUint24 = 0;
+        }
+    }
+    return taBytes;
+}
+exports.base64Decode = base64Decode;

package/dist/utils/crc16.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function crc16(data: string | Buffer): number;

package/dist/utils/crc16.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc16 = void 0;
+const TABLE = new Int16Array([
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+]);
+function crc16(data) {
+    if (!(data instanceof Buffer)) {
+        data = Buffer.from(data);
+    }
+    let crc = 0;
+    for (let index = 0; index < data.length; index++) {
+        const byte = data[index];
+        crc = (TABLE[((crc >> 8) ^ byte) & 0xff] ^ (crc << 8)) & 0xffff;
+    }
+    return crc;
+}
+exports.crc16 = crc16;

package/dist/utils/message.d.ts

@@ -0,0 +1,15 @@
+import { Address, Cell, Message, StateInit } from "ton-core";
+export declare function internal(params: {
+    from: Address;
+    to: Address;
+    value: bigint;
+    body?: Cell;
+    stateInit?: StateInit;
+    bounce?: boolean;
+    bounced?: boolean;
+    ihrDisabled?: boolean;
+    ihrFee?: bigint;
+    forwardFee?: bigint;
+    createdAt?: number;
+    createdLt?: bigint;
+}): Message;

package/dist/utils/message.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internal = void 0;
+const ton_core_1 = require("ton-core");
+function internal(params) {
+    return {
+        info: {
+            type: 'internal',
+            dest: params.to,
+            src: params.from,
+            value: { coins: params.value },
+            bounce: params.bounce ?? true,
+            ihrDisabled: params.ihrDisabled ?? true,
+            bounced: params.bounced ?? false,
+            ihrFee: params.ihrFee ?? 0n,
+            forwardFee: params.forwardFee ?? 0n,
+            createdAt: params.createdAt ?? 0,
+            createdLt: params.createdLt ?? 0n,
+        },
+        body: params.body ?? new ton_core_1.Cell(),
+        init: params.stateInit,
+    };
+}
+exports.internal = internal;

package/dist/utils/prettyLogTransaction.d.ts

@@ -0,0 +1,3 @@
+import { Transaction } from "ton-core";
+export declare function prettyLogTransaction(tx: Transaction): string;
+export declare function prettyLogTransactions(txs: Transaction[]): void;

package/dist/utils/prettyLogTransaction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyLogTransactions = exports.prettyLogTransaction = void 0;
+const ton_core_1 = require("ton-core");
+function prettyLogTransaction(tx) {
+    let res = `${tx.inMessage?.info.src}  ➡️  ${tx.inMessage?.info.dest}\n`;
+    for (let message of tx.outMessages.values()) {
+        if (message.info.type === 'internal') {
+            res += `     ➡️  ${(0, ton_core_1.fromNano)(message.info.value.coins)} 💎 ${message.info.dest}\n`;
+        }
+        else {
+            res += `      ➡️  ${message.info.dest}\n`;
+        }
+    }
+    return res;
+}
+exports.prettyLogTransaction = prettyLogTransaction;
+function prettyLogTransactions(txs) {
+    let out = '';
+    for (let tx of txs) {
+        out += prettyLogTransaction(tx) + '\n\n';
+    }
+    console.log(out);
+}
+exports.prettyLogTransactions = prettyLogTransactions;

package/dist/utils/printTransactionFees.d.ts

@@ -0,0 +1,3 @@
+import { Transaction } from "ton-core";
+export declare function formatCoinsPure(value: bigint, precision?: number): string;
+export declare function printTransactionFees(transactions: Transaction[]): void;

package/dist/utils/printTransactionFees.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTransactionFees = exports.formatCoinsPure = void 0;
+const decimalCount = 9;
+const decimal = pow10(decimalCount);
+function pow10(n) {
+    let v = 1n;
+    for (let i = 0; i < n; i++) {
+        v *= 10n;
+    }
+    return v;
+}
+function formatCoinsPure(value, precision = 6) {
+    let whole = value / decimal;
+    let frac = value % decimal;
+    const precisionDecimal = pow10(decimalCount - precision);
+    if (frac % precisionDecimal > 0n) { // round up
+        frac += precisionDecimal;
+        if (frac >= decimal) {
+            frac -= decimal;
+            whole += 1n;
+        }
+    }
+    frac /= precisionDecimal;
+    return `${whole.toString()}${frac !== 0n ? ('.' + frac.toString().padStart(precision, '0').replace(/0+$/, '')) : ''}`;
+}
+exports.formatCoinsPure = formatCoinsPure;
+function formatCoins(value, precision = 6) {
+    if (value === undefined)
+        return 'N/A';
+    return formatCoinsPure(value, precision) + ' TON';
+}
+function printTransactionFees(transactions) {
+    console.table(transactions
+        .map((tx) => {
+        if (tx.description.type !== 'generic')
+            return undefined;
+        const body = tx.inMessage?.info.type === 'internal' ? tx.inMessage?.body.beginParse() : undefined;
+        const op = body === undefined ? 'N/A' : (body.remainingBits >= 32 ? body.preloadUint(32) : 'no body');
+        const totalFees = formatCoins(tx.totalFees.coins);
+        const computeFees = formatCoins(tx.description.computePhase.type === 'vm' ? tx.description.computePhase.gasFees : undefined);
+        const totalFwdFees = formatCoins(tx.description.actionPhase?.totalFwdFees ?? undefined);
+        const valueIn = formatCoins(tx.inMessage?.info.type === 'internal' ? tx.inMessage.info.value.coins : undefined);
+        const valueOut = formatCoins(tx.outMessages
+            .values()
+            .reduce((total, message) => total + (message.info.type === 'internal' ? message.info.value.coins : 0n), 0n));
+        const forwardIn = formatCoins(tx.inMessage?.info.type === 'internal' ? tx.inMessage.info.forwardFee : undefined);
+        return {
+            op: typeof op === 'number' ? ('0x' + op.toString(16)) : op,
+            valueIn,
+            valueOut,
+            totalFees: totalFees,
+            inForwardFee: forwardIn,
+            outForwardFee: totalFwdFees,
+            outActions: tx.description.actionPhase?.totalActions ?? 'N/A',
+            computeFee: computeFees,
+            exitCode: tx.description.computePhase.type === 'vm' ? tx.description.computePhase.exitCode : 'N/A',
+            actionCode: tx.description.actionPhase?.resultCode ?? 'N/A',
+        };
+    })
+        .filter((v) => v !== undefined));
+}
+exports.printTransactionFees = printTransactionFees;

package/dist/utils/selector.d.ts

@@ -0,0 +1 @@
+export declare function getSelectorForMethod(methodName: string): number;

package/dist/utils/selector.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectorForMethod = void 0;
+const crc16_1 = require("./crc16");
+function getSelectorForMethod(methodName) {
+    if (methodName === 'main') {
+        return 0;
+    }
+    else if (methodName === 'recv_internal') {
+        return 0;
+    }
+    else if (methodName === 'recv_external') {
+        return -1;
+    }
+    else {
+        return ((0, crc16_1.crc16)(methodName) & 0xffff) | 0x10000;
+    }
+}
+exports.getSelectorForMethod = getSelectorForMethod;

package/dist/utils/testTreasurySubwalletId.d.ts

@@ -0,0 +1 @@
+export declare function testSubwalletId(seed: string): bigint;

package/dist/utils/testTreasurySubwalletId.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testSubwalletId = void 0;
+const ton_crypto_1 = require("ton-crypto");
+const prefix = 'TESTSEED';
+function testSubwalletId(seed) {
+    return BigInt('0x' + (0, ton_crypto_1.sha256_sync)(prefix + seed).toString('hex'));
+}
+exports.testSubwalletId = testSubwalletId;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@ton/sandbox",
+  "version": "0.11.0",
+  "description": "TON transaction emulator",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "author": "TonTech",
+  "files": [
+    "dist/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ton-org/sandbox"
+  },
+  "devDependencies": {
+    "@ton-community/test-utils": "^0.2.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "jest": "^29.5.0",
+    "ton": "^13.4.1",
+    "ton-core": "^0.49.0",
+    "ton-crypto": "3.2.0",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
+  },
+  "peerDependencies": {
+    "ton-core": ">=0.48.0",
+    "ton-crypto": ">=3.2.0"
+  },
+  "scripts": {
+    "wasm:pack": "ts-node ./scripts/pack-wasm.ts",
+    "wasm:copy": "cp src/executor/emulator-emscripten.js src/executor/emulator-emscripten.wasm.js ./dist/executor",
+    "test": "yarn wasm:pack && yarn jest src",
+    "build": "rm -rf dist && yarn wasm:pack && yarn test && tsc && yarn wasm:copy",
+    "config:pack": "ts-node ./scripts/pack-config.ts"
+  }
+}