@ton/sandbox 0.21.0-beta.1 → 0.21.0-debugger.0

package/dist/debugger/Debuggee.js

@@ -0,0 +1,467 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TVMDebugSession = exports.Debuggee = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const debugadapter_1 = require("@vscode/debugadapter");
+const node_path_1 = require("node:path");
+class Debuggee extends node_events_1.default {
+    constructor(executor, finishedCallback) {
+        super();
+        this.ptr = 0;
+        this.debugType = 'get';
+        this.sourceMap = {};
+        this.availableLines = {};
+        this.codeCells = new Map();
+        this.breakpoints = new Map();
+        this.breakpointID = 0;
+        this.frames = [];
+        this.executor = executor;
+        this.executor.debugLogFunc = (s) => { this.sendEvent('output', s); };
+        this.finishedCallback = finishedCallback;
+    }
+    setCodeCells(code) {
+        const q = [code];
+        while (q.length > 0) {
+            const c = q.pop();
+            const h = c.hash().toString('hex').toUpperCase();
+            this.codeCells.set(h, c);
+            for (const r of c.refs) {
+                q.push(r);
+            }
+        }
+    }
+    setSourceMap(sourceMap) {
+        this.sourceMap = sourceMap;
+        for (const di in sourceMap) {
+            const sem = sourceMap[di];
+            if (!(sem.path in this.availableLines)) {
+                this.availableLines[sem.path] = [];
+            }
+            this.availableLines[sem.path].push(sem.line);
+        }
+    }
+    getAvailableSourcePaths() {
+        return Object.keys(this.availableLines);
+    }
+    getAvailableLines(path) {
+        return this.availableLines[path] ?? [];
+    }
+    isLineAvailable(path, line) {
+        if (!(path in this.availableLines)) {
+            return false;
+        }
+        const lines = this.availableLines[path];
+        return lines.indexOf(line) >= 0;
+    }
+    continue() {
+        this.stepUntilLine(true);
+    }
+    step(stopEvent = 'stopOnStep') {
+        this.stepUntilLine(false, stopEvent);
+    }
+    startGetMethod(args) {
+        this.ptr = this.executor.sbsGetMethodSetup(args);
+        this.debugType = 'get';
+    }
+    startTransaction(args) {
+        const { emptr, res } = this.executor.sbsTransactionSetup(args);
+        if (res !== 1) {
+            throw new Error('Could not setup SBS transaction, result: ' + res);
+        }
+        this.ptr = emptr;
+        this.debugType = 'tx';
+    }
+    vmStep() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodStep(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionStep(this.ptr);
+        }
+    }
+    codePos() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodCodePos(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionCodePos(this.ptr);
+        }
+    }
+    getStack() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodStack(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionStack(this.ptr);
+        }
+    }
+    currentDebugInfoNumber() {
+        const codepos = this.codePos();
+        const cell = this.codeCells.get(codepos.hash);
+        if (cell !== undefined) {
+            try {
+                const s = cell.beginParse();
+                s.skip(codepos.offset);
+                const opp = s.loadUint(12);
+                if (opp !== 0xfef) {
+                    return undefined;
+                }
+                const n = s.loadUint(4);
+                const b = s.loadBuffer(n + 1);
+                const bstr = b.toString('utf-8');
+                if (!bstr.startsWith('DI')) {
+                    return undefined;
+                }
+                return parseInt(bstr.slice(2));
+            }
+            catch (e) { }
+        }
+        return undefined;
+    }
+    currentSourceMapEntry() {
+        const di = this.currentDebugInfoNumber();
+        if (di === undefined) {
+            return undefined;
+        }
+        return this.sourceMap[di];
+    }
+    breakpointKey(path, line) {
+        return path + ':' + line;
+    }
+    splitBreakpointKey(k) {
+        const i = k.lastIndexOf(':');
+        return {
+            path: k.slice(0, i),
+            line: parseInt(k.slice(i + 1)),
+        };
+    }
+    clearBreakpoints(path) {
+        this.breakpoints.set(path, []);
+    }
+    hasBreakpoint(path, line) {
+        return (this.breakpoints.get(path) ?? []).findIndex(v => v.line === line) >= 0;
+    }
+    setBreakpoint(path, line) {
+        let arr = this.breakpoints.get(path);
+        if (arr === undefined) {
+            arr = [];
+            this.breakpoints.set(path, arr);
+        }
+        const bp = {
+            id: this.breakpointID++,
+            line,
+            verified: this.isLineAvailable(path, line),
+        };
+        arr.push(bp);
+        return bp;
+    }
+    sendEvent(event, ...args) {
+        setTimeout(() => {
+            this.emit(event, ...args);
+        }, 0);
+    }
+    onFinished() {
+        this.sendEvent('end');
+        let r;
+        switch (this.debugType) {
+            case 'get': {
+                r = this.executor.sbsGetMethodResult(this.ptr);
+                this.executor.destroyTvmEmulator(this.ptr);
+                break;
+            }
+            case 'tx': {
+                r = this.executor.sbsTransactionResult(this.ptr);
+                this.executor.destroyEmulator(this.ptr);
+                break;
+            }
+        }
+        this.finishedCallback(r);
+    }
+    stepUntilLine(breakpointsOnly, stopEvent) {
+        while (true) {
+            const finished = this.vmStep();
+            if (finished) {
+                this.onFinished();
+                return;
+            }
+            const sme = this.currentSourceMapEntry();
+            if (sme !== undefined && (!breakpointsOnly || this.hasBreakpoint(sme.path, sme.line))) {
+                if (breakpointsOnly) {
+                    this.sendEvent('stopOnBreakpoint');
+                }
+                else if (stopEvent !== undefined) {
+                    this.sendEvent(stopEvent);
+                }
+                return;
+            }
+        }
+    }
+    prepareGetMethod(args, sourceMap) {
+        this.startGetMethod(args);
+        this.setCodeCells(args.code);
+        this.setSourceMap(sourceMap);
+    }
+    prepareTransaction(args, code, sourceMap) {
+        this.startTransaction(args);
+        this.setCodeCells(code);
+        this.setSourceMap(sourceMap);
+    }
+    start(debug, stopOnEntry) {
+        if (debug) {
+            if (stopOnEntry) {
+                this.step('stopOnEntry');
+            }
+            else {
+                this.continue();
+            }
+        }
+        else {
+            this.continue();
+        }
+    }
+}
+exports.Debuggee = Debuggee;
+class TVMDebugSession extends debugadapter_1.LoggingDebugSession {
+    constructor(debuggee) {
+        super();
+        this.debuggee = debuggee;
+        this.debuggee.on('stopOnEntry', () => {
+            this.sendEvent(new debugadapter_1.StoppedEvent('entry', TVMDebugSession.threadID));
+        });
+        this.debuggee.on('stopOnBreakpoint', () => {
+            this.sendEvent(new debugadapter_1.StoppedEvent('breakpoint', TVMDebugSession.threadID));
+        });
+        this.debuggee.on('stopOnStep', () => {
+            this.sendEvent(new debugadapter_1.StoppedEvent('step', TVMDebugSession.threadID));
+        });
+        this.debuggee.on('end', () => {
+            this.sendEvent(new debugadapter_1.TerminatedEvent());
+        });
+        this.debuggee.on('output', (s) => {
+            this.sendEvent(new debugadapter_1.OutputEvent(s + '\n', 'stdout'));
+        });
+    }
+    initializeRequest(response, args) {
+        response.body = response.body || {};
+        const b = response.body;
+        b.supportsConfigurationDoneRequest = false;
+        b.supportsFunctionBreakpoints = false;
+        b.supportsConditionalBreakpoints = false;
+        b.supportsHitConditionalBreakpoints = false;
+        b.supportsEvaluateForHovers = false;
+        b.supportsStepBack = false;
+        b.supportsSetVariable = false;
+        b.supportsRestartFrame = false;
+        b.supportsGotoTargetsRequest = false;
+        b.supportsStepInTargetsRequest = false;
+        b.supportsCompletionsRequest = false;
+        b.supportsModulesRequest = false;
+        b.supportsRestartRequest = false;
+        b.supportsValueFormattingOptions = false;
+        b.supportsExceptionInfoRequest = false;
+        b.supportTerminateDebuggee = false;
+        b.supportSuspendDebuggee = false;
+        b.supportsDelayedStackTraceLoading = false;
+        b.supportsLoadedSourcesRequest = true;
+        b.supportsLogPoints = false;
+        b.supportsTerminateThreadsRequest = false;
+        b.supportsSetExpression = false;
+        b.supportsTerminateRequest = false;
+        b.supportsDataBreakpoints = false;
+        b.supportsReadMemoryRequest = false;
+        b.supportsWriteMemoryRequest = false;
+        b.supportsDisassembleRequest = false;
+        b.supportsCancelRequest = false;
+        b.supportsBreakpointLocationsRequest = true;
+        b.supportsClipboardContext = false;
+        b.supportsSteppingGranularity = false;
+        b.supportsInstructionBreakpoints = false;
+        b.supportsExceptionFilterOptions = false;
+        b.supportsSingleThreadExecutionRequests = false;
+        this.sendResponse(response);
+        this.sendEvent(new debugadapter_1.InitializedEvent());
+    }
+    loadedSourcesRequest(response, args, request) {
+        response.body = response.body || {};
+        response.body.sources = this.debuggee.getAvailableSourcePaths().map(v => ({
+            path: v,
+            name: (0, node_path_1.basename)(v),
+        }));
+        this.sendResponse(response);
+    }
+    breakpointLocationsRequest(response, args, request) {
+        response.body = response.body || {};
+        const path = args.source.path;
+        if (path === undefined) {
+            this.sendErrorResponse(response, {
+                id: 1001,
+                format: 'No path',
+            });
+            return;
+        }
+        response.body.breakpoints = this.debuggee.getAvailableLines(path).filter(l => l >= args.line && l <= (args.endLine ?? args.line)).map(l => ({
+            line: l,
+        }));
+        this.sendResponse(response);
+    }
+    launchRequest(response, args, request) {
+        debugadapter_1.logger.setup(debugadapter_1.Logger.LogLevel.Verbose);
+        this.debuggee.start(!args.noDebug, true);
+        this.sendResponse(response);
+    }
+    attachRequest(response, args, request) {
+        this.launchRequest(response, args, request);
+    }
+    setBreakPointsRequest(response, args, request) {
+        const path = args.source.path;
+        if (path === undefined) {
+            this.sendErrorResponse(response, {
+                id: 1001,
+                format: 'No path',
+            });
+            return;
+        }
+        const breakpoints = args.breakpoints;
+        if (breakpoints === undefined) {
+            this.sendErrorResponse(response, {
+                id: 1002,
+                format: 'No breakpoints',
+            });
+            return;
+        }
+        this.debuggee.clearBreakpoints(path);
+        const bps = [];
+        for (const bp of breakpoints) {
+            const sbp = this.debuggee.setBreakpoint(path, bp.line);
+            bps.push({
+                id: sbp.id,
+                line: sbp.line,
+                verified: sbp.verified,
+            });
+        }
+        response.body = {
+            breakpoints: bps,
+        };
+        this.sendResponse(response);
+    }
+    threadsRequest(response, request) {
+        response.body = {
+            threads: [
+                new debugadapter_1.Thread(TVMDebugSession.threadID, 'main'),
+            ],
+        };
+        this.sendResponse(response);
+    }
+    continueRequest(response, args, request) {
+        this.debuggee.continue();
+        this.sendResponse(response);
+    }
+    nextRequest(response, args, request) {
+        this.debuggee.step();
+        this.sendResponse(response);
+    }
+    stepInRequest(response, args, request) {
+        this.debuggee.step();
+        this.sendResponse(response);
+    }
+    stepOutRequest(response, args, request) {
+        this.debuggee.step();
+        this.sendResponse(response);
+    }
+    stackTraceRequest(response, args, request) {
+        response.body = response.body || {};
+        const sme = this.debuggee.currentSourceMapEntry();
+        if (sme === undefined) {
+            response.body.stackFrames = [];
+            response.body.totalFrames = 0;
+            this.sendResponse(response);
+            return;
+        }
+        response.body.totalFrames = 1;
+        if (args.startFrame ?? 0 > 0) {
+            response.body.stackFrames = [];
+            this.sendResponse(response);
+            return;
+        }
+        response.body.stackFrames = [{
+                id: TVMDebugSession.stackFrameID,
+                name: 'func',
+                line: sme.line,
+                column: 0,
+                source: {
+                    name: (0, node_path_1.basename)(sme.path),
+                    path: sme.path,
+                },
+            }];
+        this.sendResponse(response);
+    }
+    scopesRequest(response, args, request) {
+        response.body = response.body || {};
+        const sme = this.debuggee.currentSourceMapEntry();
+        if (sme === undefined) {
+            response.body.scopes = [];
+            this.sendResponse(response);
+            return;
+        }
+        response.body.scopes = [{
+                name: 'Locals',
+                variablesReference: TVMDebugSession.variablesReference,
+                expensive: false,
+            }];
+        this.sendResponse(response);
+    }
+    variablesRequest(response, args, request) {
+        response.body = response.body || {};
+        response.body.variables = [];
+        const sme = this.debuggee.currentSourceMapEntry();
+        if (sme === undefined) {
+            this.sendResponse(response);
+            return;
+        }
+        const stack = this.debuggee.getStack();
+        for (let i = 0; i < sme.variables.length; i++) {
+            response.body.variables.push({
+                name: sme.variables[i],
+                value: tupleItemToString(stack[i]),
+                type: stack[i].type,
+                variablesReference: 0,
+            });
+        }
+        response.body.variables.sort((a, b) => (a.name < b.name) ? -1 : (a.name > b.name ? 1 : 0));
+        this.sendResponse(response);
+    }
+    disconnectRequest(response, args, request) {
+        if (args.restart) {
+            this.sendErrorResponse(response, {
+                id: 1003,
+                format: 'Cannot restart',
+            });
+        }
+        else {
+            this.sendResponse(response);
+        }
+    }
+}
+exports.TVMDebugSession = TVMDebugSession;
+TVMDebugSession.threadID = 1;
+TVMDebugSession.stackFrameID = 1;
+TVMDebugSession.variablesReference = 1;
+function tupleItemToString(ti) {
+    switch (ti.type) {
+        case 'int':
+            return ti.value.toString();
+        case 'null':
+            return 'null';
+        case 'nan':
+            return 'NaN';
+        case 'cell':
+        case 'slice':
+        case 'builder':
+            return ti.cell.toBoc().toString('base64');
+        case 'tuple':
+            return `[${ti.items.map(v => tupleItemToString(v)).join(', ')}]`;
+    }
+}

package/dist/debugger/SourceMapCache.d.ts

@@ -0,0 +1,5 @@
+import { SourceMap } from "./Debuggee";
+import { CompileResult } from '@ton/blueprint';
+export type SourceMapCache = Map<string, SourceMap>;
+export declare const defaultSourceMapCache: SourceMapCache;
+export declare function registerCompiledContract(c: CompileResult): import("@ton/core").Cell;

package/dist/debugger/SourceMapCache.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompiledContract = exports.defaultSourceMapCache = void 0;
+const node_path_1 = require("node:path");
+exports.defaultSourceMapCache = new Map();
+function registerCompiledContract(c) {
+    if (c.lang !== 'func') {
+        throw new Error('Can only register func contracts');
+    }
+    if (c.debugInfo === undefined) {
+        throw new Error('No debug info');
+    }
+    const sm = {};
+    for (let i = 0; i < c.debugInfo.length; i++) {
+        const di = c.debugInfo[i];
+        if (di.ret || di.vars === undefined)
+            continue;
+        sm[i] = {
+            path: (0, node_path_1.resolve)(di.file),
+            line: di.line,
+            variables: di.vars ?? [],
+        };
+    }
+    exports.defaultSourceMapCache.set(c.code.hash().toString('base64'), sm);
+    return c.code;
+}
+exports.registerCompiledContract = registerCompiledContract;

package/dist/debugger/debug.d.ts

@@ -0,0 +1,5 @@
+import { Cell } from '@ton/core';
+import { GetMethodArgs, Executor, GetMethodResult, RunTransactionArgs, EmulationResult } from '../executor/Executor';
+import { SourceMap } from "./Debuggee";
+export declare function debugGetMethod(executor: Executor, args: GetMethodArgs, sourceMap: SourceMap): Promise<GetMethodResult>;
+export declare function debugTransaction(executor: Executor, args: RunTransactionArgs, code: Cell, sourceMap: SourceMap): Promise<EmulationResult>;

package/dist/debugger/debug.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugTransaction = exports.debugGetMethod = void 0;
+const Debuggee_1 = require("./Debuggee");
+const Net = __importStar(require("net"));
+function initDebuggee(executor) {
+    let dbg = null;
+    const promise = new Promise((resolve) => {
+        dbg = new Debuggee_1.Debuggee(executor, resolve);
+    });
+    return { dbg, promise };
+}
+async function debugGetMethod(executor, args, sourceMap) {
+    console.log('Launched get method debug session. Please connect using the extension.');
+    const { dbg, promise } = initDebuggee(executor);
+    dbg.prepareGetMethod(args, sourceMap);
+    const server = Net.createServer((socket) => {
+        const session = new Debuggee_1.TVMDebugSession(dbg);
+        session.setRunAsServer(true);
+        session.start(socket, socket);
+    }).listen(42069);
+    const result = await promise;
+    server.close();
+    return result;
+}
+exports.debugGetMethod = debugGetMethod;
+async function debugTransaction(executor, args, code, sourceMap) {
+    console.log('Launched transaction debug session. Please connect using the extension.');
+    const { dbg, promise } = initDebuggee(executor);
+    dbg.prepareTransaction(args, code, sourceMap);
+    const server = Net.createServer((socket) => {
+        const session = new Debuggee_1.TVMDebugSession(dbg);
+        session.setRunAsServer(true);
+        session.start(socket, socket);
+    }).listen(42069);
+    const result = await promise;
+    server.close();
+    return result;
+}
+exports.debugTransaction = debugTransaction;

package/dist/executor/Executor.d.ts

@@ -82,18 +82,37 @@ export declare class Executor implements IExecutor {
     private heap;
     private emulator?;
     private debugLogs;
+    debugLogFunc: (s: string) => void;
     private constructor();
+    private handleLog;
     static create(): Promise<Executor>;
     runGetMethod(args: GetMethodArgs): Promise<GetMethodResult>;
     private runCommon;
     runTickTock(args: RunTickTockArgs): Promise<EmulationResult>;
     runTransaction(args: RunTransactionArgs): Promise<EmulationResult>;
-    getVersion(): {
-        commitHash: string;
-        commitDate: string;
-    };
     private createEmulator;
     private getEmulatorPointer;
     invoke(method: string, args: (number | string)[]): number;
     private extractString;
+    sbsGetMethodSetup(args: GetMethodArgs): number;
+    destroyTvmEmulator(ptr: number): void;
+    sbsGetMethodStep(ptr: number): boolean;
+    sbsGetMethodStack(ptr: number): TupleItem[];
+    sbsGetMethodCodePos(ptr: number): {
+        hash: string;
+        offset: number;
+    };
+    sbsGetMethodResult(ptr: number): GetMethodResult;
+    sbsTransactionSetup(args: RunTransactionArgs): {
+        res: number;
+        emptr: number;
+    };
+    destroyEmulator(ptr: number): void;
+    sbsTransactionStep(ptr: number): boolean;
+    sbsTransactionCodePos(ptr: number): {
+        hash: string;
+        offset: number;
+    };
+    sbsTransactionStack(ptr: number): TupleItem[];
+    sbsTransactionResult(ptr: number): EmulationResult;
 }