@ton/sandbox 0.39.0 → 0.40.0

package/dist/jest/uiSetup.d.ts

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

package/dist/jest/uiSetup.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const Blockchain_1 = require("../blockchain/Blockchain");
+const ManagedWebSocketConnector_1 = require("../ui/connection/websocket/ManagedWebSocketConnector");
+let websocketConnector;
+beforeAll(() => {
+    const originalCreate = Blockchain_1.Blockchain.create.bind(Blockchain_1.Blockchain);
+    Blockchain_1.Blockchain.create = async (...args) => {
+        let [opts, ...otherArgs] = args;
+        if (!opts?.uiOptions?.connector) {
+            if (!websocketConnector) {
+                websocketConnector = new ManagedWebSocketConnector_1.ManagedWebSocketConnector(opts?.uiOptions);
+                // eslint-disable-next-line no-console
+                console.log('Connecting to websocket connector...');
+                await websocketConnector.connect();
+            }
+            opts = {
+                ...opts,
+                uiOptions: {
+                    ...opts?.uiOptions,
+                    enabled: true,
+                    connector: websocketConnector,
+                },
+            };
+        }
+        return await originalCreate(opts, ...otherArgs);
+    };
+});
+beforeEach(() => {
+    expect.setState({ testId: (0, crypto_1.randomUUID)() });
+});
+afterEach(() => {
+    expect.setState({ testId: undefined });
+});
+afterAll(() => {
+    websocketConnector?.disconnect();
+});

package/dist/ui/UIManager.d.ts

@@ -0,0 +1,18 @@
+import { Address } from '@ton/core';
+import { BlockchainTransaction } from '../blockchain/Blockchain';
+import { ContractMeta } from '../meta/ContractsMeta';
+import { SmartContract } from '../blockchain/SmartContract';
+import { IUIConnector } from './connection/UIConnector';
+export interface IUIManager {
+    publishTransactions(transactions: BlockchainTransaction[]): void;
+}
+export declare class UIManager implements IUIManager {
+    private readonly connector;
+    private readonly blockchain;
+    constructor(connector: IUIConnector, blockchain: {
+        getMeta(address: Address): ContractMeta | undefined;
+        knownContracts(): SmartContract[];
+    });
+    publishTransactions(txs: BlockchainTransaction[]): void;
+    private getTestInfo;
+}

package/dist/ui/UIManager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIManager = void 0;
+const protocol_1 = require("./protocol");
+class UIManager {
+    connector;
+    blockchain;
+    constructor(connector, blockchain) {
+        this.connector = connector;
+        this.blockchain = blockchain;
+    }
+    publishTransactions(txs) {
+        let testInfo = this.getTestInfo();
+        const transactions = (0, protocol_1.serializeTransactions)(txs);
+        const knownContracts = this.blockchain.knownContracts();
+        const contracts = (0, protocol_1.serializeContracts)(knownContracts.map((contract) => ({ contract, meta: this.blockchain.getMeta(contract.address) })));
+        this.connector.send(JSON.stringify({ type: 'test-data', testInfo, transactions, contracts }));
+    }
+    getTestInfo() {
+        if (expect === undefined) {
+            return;
+        }
+        const expectState = expect.getState();
+        return {
+            id: expectState.testId,
+            name: expectState.currentTestName,
+            path: expectState.testPath,
+        };
+    }
+}
+exports.UIManager = UIManager;

package/dist/ui/connection/UIConnector.d.ts

@@ -0,0 +1,3 @@
+export interface IUIConnector {
+    send(data: string): void;
+}

package/dist/ui/connection/UIConnector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/connection/websocket/ManagedWebSocketConnector.d.ts

@@ -0,0 +1,10 @@
+import { WebSocketConnectionOptions } from './types';
+import { IUIConnector } from '../UIConnector';
+export declare class ManagedWebSocketConnector implements IUIConnector {
+    private readonly websocketAddress;
+    ws: WebSocket | undefined;
+    constructor({ wsPort, wsHost }?: WebSocketConnectionOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(data: string): void;
+}

package/dist/ui/connection/websocket/ManagedWebSocketConnector.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedWebSocketConnector = void 0;
+const environment_1 = require("../../../utils/environment");
+const constants_1 = require("./constants");
+class ManagedWebSocketConnector {
+    websocketAddress;
+    ws;
+    constructor({ wsPort = constants_1.DEFAULT_PORT, wsHost = constants_1.DEFAULT_HOST } = {}) {
+        this.websocketAddress = (0, environment_1.getOptionalEnv)('SANDBOX_WEBSOCKET_ADDR') ?? `ws://${wsHost}:${wsPort}`;
+    }
+    async connect() {
+        try {
+            this.ws = await new Promise((resolve, reject) => {
+                const ws = new WebSocket(this.websocketAddress);
+                ws.addEventListener('open', () => resolve(ws), { once: true });
+                ws.addEventListener('error', (err) => {
+                    ws.close();
+                    reject(err);
+                }, { once: true });
+            });
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn(constants_1.CONNECT_ERROR_MESSAGE, err);
+        }
+    }
+    disconnect() {
+        this.ws?.close();
+        this.ws = undefined;
+    }
+    send(data) {
+        if (this?.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(data);
+        }
+    }
+}
+exports.ManagedWebSocketConnector = ManagedWebSocketConnector;

package/dist/ui/connection/websocket/OneTimeWebSocketConnector.d.ts

@@ -0,0 +1,7 @@
+import { WebSocketConnectionOptions } from './types';
+import { IUIConnector } from '../UIConnector';
+export declare class OneTimeWebSocketConnector implements IUIConnector {
+    private readonly websocketAddress;
+    constructor({ wsPort, wsHost }: WebSocketConnectionOptions);
+    send(data: string): void;
+}

package/dist/ui/connection/websocket/OneTimeWebSocketConnector.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneTimeWebSocketConnector = void 0;
+const environment_1 = require("../../../utils/environment");
+const constants_1 = require("./constants");
+class OneTimeWebSocketConnector {
+    websocketAddress;
+    constructor({ wsPort = constants_1.DEFAULT_PORT, wsHost = constants_1.DEFAULT_HOST }) {
+        this.websocketAddress = (0, environment_1.getOptionalEnv)('SANDBOX_WEBSOCKET_ADDR') ?? `ws://${wsHost}:${wsPort}`;
+    }
+    send(data) {
+        // This solution, which requires a reconnection for each send, may seem inefficient.
+        // However, when Jest is not used, it’s unclear when the connection should be closed.
+        // Until the connection is closed, the Node process will not terminate, and Jest will issue
+        // a warning, while the test will continue to wait for the connection to close.
+        //
+        // This solution avoids that problem, as the connection is closed immediately after sending.
+        // Meanwhile, the reconnection time is short enough to be unnoticeable during tests.
+        const ws = new WebSocket(this.websocketAddress);
+        ws.addEventListener('open', () => {
+            ws.send(data);
+            ws.close();
+        }, { once: true });
+        ws.addEventListener('error', (err) => {
+            // eslint-disable-next-line no-console
+            console.warn(constants_1.CONNECT_ERROR_MESSAGE, err);
+            ws.close();
+        }, { once: true });
+    }
+}
+exports.OneTimeWebSocketConnector = OneTimeWebSocketConnector;

package/dist/ui/connection/websocket/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_PORT = 7743;
+export declare const DEFAULT_HOST = "localhost";
+export declare const CONNECT_ERROR_MESSAGE = "Unable to connect to websocket server. Make sure the port and host match the sandbox server or VS Code settings. You can set the WebSocket address globally with `SANDBOX_WEBSOCKET_ADDR=ws://localhost:7743` or via `Blockchain.create({ uiOptions: { enabled: true, wsHost: \"localhost\", wsPort: 7743 } })`.";

package/dist/ui/connection/websocket/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONNECT_ERROR_MESSAGE = exports.DEFAULT_HOST = exports.DEFAULT_PORT = void 0;
+exports.DEFAULT_PORT = 7743;
+exports.DEFAULT_HOST = 'localhost';
+exports.CONNECT_ERROR_MESSAGE = 'Unable to connect to websocket server. Make sure the port and host match the sandbox server or VS Code settings. You can set the WebSocket address globally with `SANDBOX_WEBSOCKET_ADDR=ws://localhost:7743` or via `Blockchain.create({ uiOptions: { enabled: true, wsHost: "localhost", wsPort: 7743 } })`.';

package/dist/ui/connection/websocket/types.d.ts

@@ -0,0 +1,4 @@
+export type WebSocketConnectionOptions = {
+    wsPort?: number;
+    wsHost?: string;
+};

package/dist/ui/connection/websocket/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/protocol.d.ts

@@ -0,0 +1,48 @@
+import { BlockchainTransaction } from '../blockchain/Blockchain';
+import { ContractMeta } from '../meta/ContractsMeta';
+import { SmartContract } from '../blockchain/SmartContract';
+declare const hexBrand: unique symbol;
+export type HexString = string & {
+    readonly [hexBrand]: true;
+};
+export type MessageTestData = {
+    readonly type: 'test-data';
+    readonly testInfo: TestInfo | undefined;
+    readonly transactions: RawTransactionsInfo;
+    readonly contracts: readonly RawContractData[];
+};
+export type Message = MessageTestData;
+export type RawTransactionsInfo = {
+    readonly transactions: readonly RawTransactionInfo[];
+};
+export type RawTransactionInfo = {
+    readonly transaction: string;
+    readonly blockchainLogs: string;
+    readonly vmLogs: string;
+    readonly debugLogs: string;
+    readonly code: string | undefined;
+    readonly sourceMap: object | undefined;
+    readonly contractName: string | undefined;
+    readonly parentId: string | undefined;
+    readonly childrenIds: string[];
+    readonly oldStorage: HexString | undefined;
+    readonly newStorage: HexString | undefined;
+    readonly callStack: string | undefined;
+};
+export declare function serializeTransactions(transactions: BlockchainTransaction[]): RawTransactionsInfo;
+export type RawContractData = {
+    readonly address: string;
+    readonly meta: ContractMeta | undefined;
+    readonly stateInit: HexString | undefined;
+    readonly account: HexString | undefined;
+};
+export declare function serializeContracts(contracts: {
+    contract: SmartContract;
+    meta?: ContractMeta;
+}[]): RawContractData[];
+export type TestInfo = {
+    readonly id?: string;
+    readonly name?: string;
+    readonly path?: string;
+};
+export {};

package/dist/ui/protocol.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeTransactions = serializeTransactions;
+exports.serializeContracts = serializeContracts;
+const core_1 = require("@ton/core");
+function serializeTransactions(transactions) {
+    return {
+        transactions: transactions.map((t) => {
+            const tx = (0, core_1.beginCell)()
+                .store((0, core_1.storeTransaction)(t))
+                .endCell()
+                .toBoc()
+                .toString('hex');
+            return {
+                transaction: tx,
+                blockchainLogs: t.blockchainLogs,
+                vmLogs: t.vmLogs,
+                debugLogs: t.debugLogs,
+                code: undefined,
+                sourceMap: undefined,
+                contractName: undefined,
+                parentId: t.parent?.lt.toString(),
+                childrenIds: t.children?.map((c) => c?.lt?.toString()),
+                oldStorage: t.oldStorage?.toBoc().toString('hex'),
+                newStorage: t.newStorage?.toBoc().toString('hex'),
+                callStack: t.callStack,
+            };
+        }),
+    };
+}
+function serializeContracts(contracts) {
+    return contracts.map(({ contract, meta }) => {
+        const state = contract.accountState;
+        const stateInit = (0, core_1.beginCell)();
+        if (state?.type === 'active') {
+            stateInit.store((0, core_1.storeStateInit)(state.state));
+        }
+        const stateInitCell = stateInit.asCell();
+        const account = contract.account;
+        const accountCell = (0, core_1.beginCell)().store((0, core_1.storeShardAccount)(account)).endCell();
+        return {
+            address: contract.address.toString(),
+            meta,
+            stateInit: stateInitCell.bits.length === 0 ? undefined : stateInitCell.toBoc().toString('hex'),
+            account: accountCell.toBoc().toString('hex'),
+        };
+    });
+}

package/dist/utils/environment.d.ts

@@ -1 +1,8 @@
 export declare function isBrowser(): boolean;
+declare const converters: {
+    readonly boolean: (value: string | undefined) => boolean | undefined;
+    readonly string: (value: string | undefined) => string | undefined;
+};
+type Converters = typeof converters;
+export declare function getOptionalEnv<EnvType extends keyof Converters = 'string'>(envName: string, envType?: EnvType): ReturnType<Converters[EnvType]> | undefined;
+export {};

package/dist/utils/environment.js

@@ -1,7 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBrowser = isBrowser;
+exports.getOptionalEnv = getOptionalEnv;
 function isBrowser() {
     // eslint-disable-next-line no-undef
     return typeof window !== 'undefined' && typeof window.document !== 'undefined';
 }
+const converters = {
+    boolean: (value) => {
+        if (!value)
+            return;
+        return value.toLowerCase() === 'true';
+    },
+    string: (value) => value,
+};
+function getOptionalEnv(envName, envType) {
+    if (!process || !process.env)
+        return undefined;
+    const converter = envType ? converters[envType] : converters.string;
+    return converter(process.env[envName]);
+}

package/dist/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare function noop(): void;

package/dist/utils/noop.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = noop;
+function noop() { }

package/dist/utils/require.d.ts

@@ -1 +1 @@
-export declare function requireOptional(id: string): any | undefined;
+export declare function requireTestUtils(): any | undefined;

package/dist/utils/require.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireOptional = requireOptional;
+exports.requireTestUtils = requireTestUtils;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function requireOptional(id) {
+function requireTestUtils() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require(id);
+        return require('@ton/test-utils');
     }
-    catch (error) {
-        if (String(error).includes('Cannot find module')) {
-            return undefined;
-        }
-        throw error;
+    catch {
+        return undefined;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/sandbox",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "description": "TON transaction emulator",
   "main": "dist/index.js",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^24.1.0",
     "eslint": "^9.28.0",
+    "globals": "^16.4.0",
     "jest": "^30.0.5",
     "jest-config": "^30.0.5",
     "jest-environment-node": "^30.0.5",
@@ -64,6 +65,6 @@
     "chalk": "^4.1.2",
     "fflate": "^0.8.2",
     "table": "^6.9.0",
-    "ton-assembly": "0.1.2"
+    "ton-assembly": "0.6.1"
   }
 }