@ton/sandbox 0.11.0

package/dist/blockchain/Blockchain.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blockchain = void 0;
+const defaultConfig_1 = require("../config/defaultConfig");
+const ton_core_1 = require("ton-core");
+const Executor_1 = require("../executor/Executor");
+const BlockchainStorage_1 = require("./BlockchainStorage");
+const Event_1 = require("../event/Event");
+const BlockchainContractProvider_1 = require("./BlockchainContractProvider");
+const BlockchainSender_1 = require("./BlockchainSender");
+const Treasury_1 = require("../treasury/Treasury");
+const AsyncLock_1 = require("../utils/AsyncLock");
+const message_1 = require("../utils/message");
+const slimConfig_1 = require("../config/slimConfig");
+const testTreasurySubwalletId_1 = require("../utils/testTreasurySubwalletId");
+const CREATE_WALLETS_PREFIX = 'CREATE_WALLETS';
+function createWalletsSeed(idx) {
+    return `${CREATE_WALLETS_PREFIX}${idx}`;
+}
+const LT_ALIGN = 1000000n;
+const TREASURY_INIT_BALANCE_TONS = 1000000;
+function blockchainConfigToBase64(config) {
+    switch (config) {
+        case 'default':
+            return defaultConfig_1.defaultConfig;
+        case 'slim':
+            return slimConfig_1.slimConfig;
+        default:
+            return config?.toBoc({ idx: false }).toString('base64') ?? defaultConfig_1.defaultConfig;
+    }
+}
+class Blockchain {
+    snapshot() {
+        return {
+            contracts: this.storage.knownContracts().map(s => s.snapshot()),
+            networkConfig: this.networkConfig,
+            lt: this.currentLt,
+            time: this.currentTime,
+            verbosity: { ...this.logsVerbosity },
+            libs: this.globalLibs,
+            nextCreateWalletIndex: this.nextCreateWalletIndex,
+        };
+    }
+    async loadFrom(snapshot) {
+        this.storage.clearKnownContracts();
+        for (const contract of snapshot.contracts) {
+            const storageContract = await this.getContract(contract.address);
+            storageContract.loadFrom(contract);
+        }
+        this.networkConfig = snapshot.networkConfig;
+        this.currentLt = snapshot.lt;
+        this.currentTime = snapshot.time;
+        this.logsVerbosity = { ...snapshot.verbosity };
+        this.globalLibs = snapshot.libs;
+        this.nextCreateWalletIndex = snapshot.nextCreateWalletIndex;
+    }
+    get now() {
+        return this.currentTime;
+    }
+    set now(now) {
+        this.currentTime = now;
+    }
+    get lt() {
+        return this.currentLt;
+    }
+    constructor(opts) {
+        this.currentLt = 0n;
+        this.messageQueue = [];
+        this.logsVerbosity = {
+            print: true,
+            blockchainLogs: false,
+            vmLogs: 'none',
+            debugLogs: true,
+        };
+        this.lock = new AsyncLock_1.AsyncLock();
+        this.contractFetches = new Map();
+        this.nextCreateWalletIndex = 0;
+        this.networkConfig = blockchainConfigToBase64(opts.config);
+        this.executor = opts.executor;
+        this.storage = opts.storage;
+    }
+    get config() {
+        return ton_core_1.Cell.fromBase64(this.networkConfig);
+    }
+    get configBase64() {
+        return this.networkConfig;
+    }
+    async sendMessage(message, params) {
+        await this.pushMessage(message);
+        return await this.runQueue(params);
+    }
+    async runTickTock(on, which, params) {
+        for (const addr of (Array.isArray(on) ? on : [on])) {
+            await this.pushTickTock(addr, which);
+        }
+        return await this.runQueue(params);
+    }
+    async runGetMethod(address, method, stack = [], params) {
+        return (await this.getContract(address)).get(method, stack, {
+            now: this.now,
+            ...params,
+        });
+    }
+    async pushMessage(message) {
+        const msg = message instanceof ton_core_1.Cell ? (0, ton_core_1.loadMessage)(message.beginParse()) : message;
+        if (msg.info.type === 'external-out') {
+            throw new Error('Cannot send external out message');
+        }
+        await this.lock.with(async () => {
+            this.messageQueue.push({
+                type: 'message',
+                ...msg,
+            });
+        });
+    }
+    async pushTickTock(on, which) {
+        await this.lock.with(async () => {
+            this.messageQueue.push({
+                type: 'ticktock',
+                on,
+                which,
+            });
+        });
+    }
+    async runQueue(params) {
+        const txes = await this.processQueue(params);
+        return {
+            transactions: txes,
+            events: txes.map(tx => tx.events).flat(),
+            externals: txes.map(tx => tx.externals).flat(),
+        };
+    }
+    async processQueue(params) {
+        params = {
+            now: this.now,
+            ...params,
+        };
+        return await this.lock.with(async () => {
+            const result = [];
+            while (this.messageQueue.length > 0) {
+                const message = this.messageQueue.shift();
+                let tx;
+                if (message.type === 'message') {
+                    if (message.info.type === 'external-out') {
+                        continue;
+                    }
+                    this.currentLt += LT_ALIGN;
+                    tx = (await this.getContract(message.info.dest)).receiveMessage(message, params);
+                }
+                else {
+                    this.currentLt += LT_ALIGN;
+                    tx = (await this.getContract(message.on)).runTickTock(message.which, params);
+                }
+                const transaction = {
+                    ...tx,
+                    events: (0, Event_1.extractEvents)(tx),
+                    parent: message.parentTransaction,
+                    children: [],
+                    externals: [],
+                };
+                transaction.parent?.children.push(transaction);
+                result.push(transaction);
+                for (const message of transaction.outMessages.values()) {
+                    if (message.info.type === 'external-out') {
+                        transaction.externals.push({
+                            info: {
+                                type: 'external-out',
+                                src: message.info.src,
+                                dest: message.info.dest ?? undefined,
+                                createdAt: message.info.createdAt,
+                                createdLt: message.info.createdLt,
+                            },
+                            init: message.init ?? undefined,
+                            body: message.body,
+                        });
+                        continue;
+                    }
+                    this.messageQueue.push({
+                        type: 'message',
+                        parentTransaction: transaction,
+                        ...message,
+                    });
+                    if (message.info.type === 'internal') {
+                        this.startFetchingContract(message.info.dest);
+                    }
+                }
+            }
+            return result;
+        });
+    }
+    provider(address, init) {
+        return new BlockchainContractProvider_1.BlockchainContractProvider({
+            getContract: (addr) => this.getContract(addr),
+            pushMessage: (msg) => this.pushMessage(msg),
+            runGetMethod: (addr, method, args) => this.runGetMethod(addr, method, args),
+            pushTickTock: (on, which) => this.pushTickTock(on, which),
+        }, address, init);
+    }
+    sender(address) {
+        return new BlockchainSender_1.BlockchainSender({
+            pushMessage: (msg) => this.pushMessage(msg),
+        }, address);
+    }
+    treasuryParamsToMapKey(workchain, seed) {
+        return `${workchain}:${seed}`;
+    }
+    async treasury(seed, params) {
+        const subwalletId = (0, testTreasurySubwalletId_1.testSubwalletId)(seed);
+        const wallet = this.openContract(Treasury_1.TreasuryContract.create(params?.workchain ?? 0, subwalletId));
+        const contract = await this.getContract(wallet.address);
+        if ((params?.predeploy ?? true) && (contract.accountState === undefined || contract.accountState.type === 'uninit')) {
+            await this.sendMessage((0, message_1.internal)({
+                from: new ton_core_1.Address(0, Buffer.alloc(32)),
+                to: wallet.address,
+                value: (0, ton_core_1.toNano)(1),
+                stateInit: wallet.init,
+            }));
+            contract.balance = params?.balance ?? (0, ton_core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
+        }
+        else if ((params?.resetBalanceIfZero ?? true) && contract.balance === 0n) {
+            contract.balance = params?.balance ?? (0, ton_core_1.toNano)(TREASURY_INIT_BALANCE_TONS);
+        }
+        return wallet;
+    }
+    async createWallets(n, params) {
+        const wallets = [];
+        for (let i = 0; i < n; i++) {
+            const seed = createWalletsSeed(this.nextCreateWalletIndex++);
+            wallets.push(await this.treasury(seed, params));
+        }
+        return wallets;
+    }
+    openContract(contract) {
+        let address;
+        let init = undefined;
+        if (!ton_core_1.Address.isAddress(contract.address)) {
+            throw Error('Invalid address');
+        }
+        address = contract.address;
+        if (contract.init) {
+            if (!(contract.init.code instanceof ton_core_1.Cell)) {
+                throw Error('Invalid init.code');
+            }
+            if (!(contract.init.data instanceof ton_core_1.Cell)) {
+                throw Error('Invalid init.data');
+            }
+            init = contract.init;
+        }
+        const provider = this.provider(address, init);
+        const blkch = this;
+        return new Proxy(contract, {
+            get(target, prop) {
+                const value = target[prop];
+                if (typeof prop === 'string' && typeof value === 'function') {
+                    if (prop.startsWith('get')) {
+                        return (...args) => value.apply(target, [provider, ...args]);
+                    }
+                    else if (prop.startsWith('send')) {
+                        return async (...args) => {
+                            const ret = value.apply(target, [provider, ...args]);
+                            if (ret instanceof Promise) {
+                                const r = await ret;
+                                return {
+                                    ...await blkch.runQueue(),
+                                    result: r,
+                                };
+                            }
+                            else {
+                                return {
+                                    ...await blkch.runQueue(),
+                                    result: ret,
+                                };
+                            }
+                        };
+                    }
+                }
+                return value;
+            }
+        });
+    }
+    startFetchingContract(address) {
+        const addrString = address.toRawString();
+        let promise = this.contractFetches.get(addrString);
+        if (promise !== undefined) {
+            return promise;
+        }
+        promise = this.storage.getContract(this, address);
+        this.contractFetches.set(addrString, promise);
+        return promise;
+    }
+    async getContract(address) {
+        const contract = await this.startFetchingContract(address);
+        this.contractFetches.delete(address.toRawString());
+        return contract;
+    }
+    get verbosity() {
+        return this.logsVerbosity;
+    }
+    set verbosity(value) {
+        this.logsVerbosity = value;
+    }
+    async setVerbosityForAddress(address, verbosity) {
+        const contract = await this.getContract(address);
+        contract.setVerbosity(verbosity);
+    }
+    setConfig(config) {
+        this.networkConfig = blockchainConfigToBase64(config);
+    }
+    async setShardAccount(address, account) {
+        const contract = await this.getContract(address);
+        contract.account = account;
+    }
+    get libs() {
+        return this.globalLibs;
+    }
+    set libs(value) {
+        this.globalLibs = value;
+    }
+    static async create(opts) {
+        return new Blockchain({
+            executor: await Executor_1.Executor.create(),
+            storage: opts?.storage ?? new BlockchainStorage_1.LocalBlockchainStorage(),
+            ...opts
+        });
+    }
+}
+exports.Blockchain = Blockchain;

package/dist/blockchain/BlockchainContractProvider.d.ts

@@ -0,0 +1,30 @@
+import { Address, Cell, ContractGetMethodResult, ContractProvider, ContractState, Message, Sender, SendMode, TupleItem } from "ton-core";
+import { TickOrTock } from "../executor/Executor";
+import { GetMethodResult, SmartContract } from "./SmartContract";
+export interface SandboxContractProvider extends ContractProvider {
+    tickTock(which: TickOrTock): Promise<void>;
+}
+export declare class BlockchainContractProvider implements SandboxContractProvider {
+    private readonly blockchain;
+    private readonly address;
+    private readonly init?;
+    constructor(blockchain: {
+        getContract(address: Address): Promise<SmartContract>;
+        pushMessage(message: Message): Promise<void>;
+        runGetMethod(address: Address, method: string, args: TupleItem[]): Promise<GetMethodResult>;
+        pushTickTock(on: Address, which: TickOrTock): Promise<void>;
+    }, address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    getState(): Promise<ContractState>;
+    get(name: string, args: TupleItem[]): Promise<ContractGetMethodResult>;
+    external(message: Cell): Promise<void>;
+    internal(via: Sender, args: {
+        value: string | bigint;
+        bounce?: boolean | null;
+        sendMode?: SendMode;
+        body?: string | Cell | null;
+    }): Promise<void>;
+    tickTock(which: TickOrTock): Promise<void>;
+}

package/dist/blockchain/BlockchainContractProvider.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainContractProvider = void 0;
+const ton_core_1 = require("ton-core");
+function bigintToBuffer(x, n = 32) {
+    const b = Buffer.alloc(n);
+    for (let i = 0; i < n; i++) {
+        b[n - i - 1] = Number((x >> BigInt(i * 8)) & 0xffn);
+    }
+    return b;
+}
+function convertState(state) {
+    if (state === undefined)
+        return {
+            type: 'uninit'
+        };
+    switch (state.type) {
+        case 'uninit':
+            return {
+                type: 'uninit'
+            };
+        case 'active':
+            return {
+                type: 'active',
+                code: state.state.code?.toBoc(),
+                data: state.state.data?.toBoc(),
+            };
+        case 'frozen':
+            return {
+                type: 'frozen',
+                stateHash: bigintToBuffer(state.stateHash)
+            };
+    }
+}
+class BlockchainContractProvider {
+    constructor(blockchain, address, init) {
+        this.blockchain = blockchain;
+        this.address = address;
+        this.init = init;
+    }
+    async getState() {
+        const contract = await this.blockchain.getContract(this.address);
+        return {
+            balance: contract.balance,
+            last: {
+                lt: contract.lastTransactionLt,
+                hash: bigintToBuffer(contract.lastTransactionHash),
+            },
+            state: convertState(contract.accountState),
+        };
+    }
+    async get(name, args) {
+        const result = await this.blockchain.runGetMethod(this.address, name, args);
+        return {
+            stack: result.stackReader,
+            gasUsed: result.gasUsed,
+            logs: result.vmLogs,
+        };
+    }
+    async external(message) {
+        const init = ((await this.getState()).state.type !== 'active' && this.init) ? this.init : undefined;
+        await this.blockchain.pushMessage({
+            info: {
+                type: 'external-in',
+                dest: this.address,
+                importFee: 0n,
+            },
+            init,
+            body: message,
+        });
+    }
+    async internal(via, args) {
+        const init = ((await this.getState()).state.type !== 'active' && this.init) ? this.init : undefined;
+        const bounce = (args.bounce !== null && args.bounce !== undefined) ? args.bounce : true;
+        const value = typeof args.value === 'string' ? (0, ton_core_1.toNano)(args.value) : args.value;
+        const body = typeof args.body === 'string' ? (0, ton_core_1.comment)(args.body) : args.body;
+        await via.send({
+            to: this.address,
+            value,
+            bounce,
+            sendMode: args.sendMode,
+            init,
+            body,
+        });
+    }
+    async tickTock(which) {
+        await this.blockchain.pushTickTock(this.address, which);
+    }
+}
+exports.BlockchainContractProvider = BlockchainContractProvider;

package/dist/blockchain/BlockchainSender.d.ts

@@ -0,0 +1,9 @@
+import { Address, Message, Sender, SenderArguments } from "ton-core";
+export declare class BlockchainSender implements Sender {
+    private readonly blockchain;
+    readonly address: Address;
+    constructor(blockchain: {
+        pushMessage(message: Message): Promise<void>;
+    }, address: Address);
+    send(args: SenderArguments): Promise<void>;
+}

package/dist/blockchain/BlockchainSender.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainSender = void 0;
+const ton_core_1 = require("ton-core");
+class BlockchainSender {
+    constructor(blockchain, address) {
+        this.blockchain = blockchain;
+        this.address = address;
+    }
+    async send(args) {
+        await this.blockchain.pushMessage({
+            info: {
+                type: 'internal',
+                ihrDisabled: true,
+                ihrFee: 0n,
+                bounce: args.bounce ?? true,
+                bounced: false,
+                src: this.address,
+                dest: args.to,
+                value: { coins: args.value },
+                forwardFee: 0n,
+                createdAt: 0,
+                createdLt: 0n,
+            },
+            body: args.body ?? new ton_core_1.Cell()
+        });
+    }
+}
+exports.BlockchainSender = BlockchainSender;

package/dist/blockchain/BlockchainStorage.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { AccountState, Address } from "ton-core";
+import { SmartContract } from "./SmartContract";
+import { Blockchain } from "./Blockchain";
+export interface BlockchainStorage {
+    getContract(blockchain: Blockchain, address: Address): Promise<SmartContract>;
+    knownContracts(): SmartContract[];
+    clearKnownContracts(): void;
+}
+export declare class LocalBlockchainStorage implements BlockchainStorage {
+    private contracts;
+    getContract(blockchain: Blockchain, address: Address): Promise<SmartContract>;
+    knownContracts(): SmartContract[];
+    clearKnownContracts(): void;
+}
+export interface RemoteBlockchainStorageClient {
+    getLastBlockSeqno(): Promise<number>;
+    getAccount(seqno: number, address: Address): Promise<{
+        state: AccountState;
+        balance: bigint;
+        lastTransaction?: {
+            lt: bigint;
+            hash: Buffer;
+        };
+    }>;
+}
+export declare function wrapTonClient4ForRemote(client: {
+    getLastBlock(): Promise<{
+        last: {
+            seqno: number;
+        };
+    }>;
+    getAccount(seqno: number, address: Address): Promise<{
+        account: {
+            state: {
+                type: "uninit";
+            } | {
+                type: "active";
+                code: string | null;
+                data: string | null;
+            } | {
+                type: "frozen";
+                stateHash: string;
+            };
+            balance: {
+                coins: string;
+            };
+            last: {
+                lt: string;
+                hash: string;
+            } | null;
+        };
+    }>;
+}): RemoteBlockchainStorageClient;
+export declare class RemoteBlockchainStorage implements BlockchainStorage {
+    private contracts;
+    private client;
+    private blockSeqno?;
+    constructor(client: RemoteBlockchainStorageClient, blockSeqno?: number);
+    private getLastBlockSeqno;
+    getContract(blockchain: Blockchain, address: Address): Promise<SmartContract>;
+    knownContracts(): SmartContract[];
+    clearKnownContracts(): void;
+}

package/dist/blockchain/BlockchainStorage.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteBlockchainStorage = exports.wrapTonClient4ForRemote = exports.LocalBlockchainStorage = void 0;
+const ton_core_1 = require("ton-core");
+const SmartContract_1 = require("./SmartContract");
+class LocalBlockchainStorage {
+    constructor() {
+        this.contracts = new Map();
+    }
+    async getContract(blockchain, address) {
+        let existing = this.contracts.get(address.toString());
+        if (!existing) {
+            existing = SmartContract_1.SmartContract.empty(blockchain, address);
+            this.contracts.set(address.toString(), existing);
+        }
+        return existing;
+    }
+    knownContracts() {
+        return Array.from(this.contracts.values());
+    }
+    clearKnownContracts() {
+        this.contracts.clear();
+    }
+}
+exports.LocalBlockchainStorage = LocalBlockchainStorage;
+function convertTonClient4State(state) {
+    switch (state.type) {
+        case 'uninit':
+            return { type: 'uninit' };
+        case 'active':
+            return { type: 'active', state: { code: state.code === null ? undefined : ton_core_1.Cell.fromBase64(state.code), data: state.data === null ? undefined : ton_core_1.Cell.fromBase64(state.data) } };
+        case 'frozen':
+            return { type: 'frozen', stateHash: BigInt('0x' + Buffer.from(state.stateHash, 'base64').toString('hex')) };
+        default:
+            throw new Error(`Unknown type ${state}`);
+    }
+}
+function wrapTonClient4ForRemote(client) {
+    return {
+        getLastBlockSeqno: async () => {
+            const last = await client.getLastBlock();
+            return last.last.seqno;
+        },
+        getAccount: async (seqno, address) => {
+            const { account } = await client.getAccount(seqno, address);
+            return {
+                state: convertTonClient4State(account.state),
+                balance: BigInt(account.balance.coins),
+                lastTransaction: account.last === null ? undefined : {
+                    lt: BigInt(account.last.lt),
+                    hash: Buffer.from(account.last.hash, 'base64'),
+                },
+            };
+        },
+    };
+}
+exports.wrapTonClient4ForRemote = wrapTonClient4ForRemote;
+class RemoteBlockchainStorage {
+    constructor(client, blockSeqno) {
+        this.contracts = new Map();
+        this.client = client;
+        this.blockSeqno = blockSeqno;
+    }
+    async getLastBlockSeqno() {
+        return this.blockSeqno ?? await this.client.getLastBlockSeqno();
+    }
+    async getContract(blockchain, address) {
+        let existing = this.contracts.get(address.toString());
+        if (!existing) {
+            let blockSeqno = await this.getLastBlockSeqno();
+            let account = await this.client.getAccount(blockSeqno, address);
+            const lt = account.lastTransaction?.lt ?? 0n;
+            existing = new SmartContract_1.SmartContract({
+                lastTransactionHash: BigInt('0x' + (account.lastTransaction?.hash?.toString('hex') ?? '0')),
+                lastTransactionLt: lt,
+                account: {
+                    addr: address,
+                    storageStats: {
+                        used: {
+                            cells: 0n,
+                            bits: 0n,
+                            publicCells: 0n,
+                        },
+                        lastPaid: 0,
+                        duePayment: null,
+                    },
+                    storage: {
+                        lastTransLt: lt === 0n ? 0n : (lt + 1n),
+                        balance: { coins: account.balance },
+                        state: account.state,
+                    },
+                },
+            }, blockchain);
+            this.contracts.set(address.toString(), existing);
+        }
+        return existing;
+    }
+    knownContracts() {
+        return Array.from(this.contracts.values());
+    }
+    clearKnownContracts() {
+        this.contracts.clear();
+    }
+}
+exports.RemoteBlockchainStorage = RemoteBlockchainStorage;