@ton/sandbox 0.21.0-debugger.1 → 0.21.0-debugger.2

package/dist/debugger/TVMDebugSession.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TVMDebugSession = void 0;
+const debugadapter_1 = require("@vscode/debugadapter");
+const node_path_1 = require("node:path");
+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.Log);
+        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.localVariablesReference,
+                expensive: false,
+            }, {
+                name: 'Globals',
+                variablesReference: TVMDebugSession.globalVariablesReference,
+                expensive: false,
+            }];
+        this.sendResponse(response);
+    }
+    variablesRequest(response, args, request) {
+        response.body = response.body || {};
+        response.body.variables = [];
+        let vars = undefined;
+        if (args.variablesReference === TVMDebugSession.localVariablesReference) {
+            vars = this.debuggee.getLocalVariables();
+        }
+        else if (args.variablesReference === TVMDebugSession.globalVariablesReference) {
+            vars = this.debuggee.getGlobalVariables();
+        }
+        if (vars === undefined) {
+            this.sendResponse(response);
+            return;
+        }
+        for (const v of vars) {
+            response.body.variables.push({
+                name: v.name,
+                value: tupleItemToString(v.value),
+                type: v.value.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.localVariablesReference = 1;
+TVMDebugSession.globalVariablesReference = 2;
+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/debug.d.ts

@@ -1,5 +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>;
+import { DebugInfo } from "./Debuggee";
+export declare function debugGetMethod(executor: Executor, args: GetMethodArgs, debugInfo: DebugInfo): Promise<GetMethodResult>;
+export declare function debugTransaction(executor: Executor, args: RunTransactionArgs, code: Cell, debugInfo: DebugInfo): Promise<EmulationResult>;

package/dist/debugger/debug.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugTransaction = exports.debugGetMethod = void 0;
 const Debuggee_1 = require("./Debuggee");
 const Net = __importStar(require("net"));
+const TVMDebugSession_1 = require("./TVMDebugSession");
 function initDebuggee(executor) {
     let dbg = null;
     const promise = new Promise((resolve) => {
@@ -33,12 +34,12 @@ function initDebuggee(executor) {
     });
     return { dbg, promise };
 }
-async function debugGetMethod(executor, args, sourceMap) {
+async function debugGetMethod(executor, args, debugInfo) {
     console.log('Launched get method debug session. Please connect using the extension.');
     const { dbg, promise } = initDebuggee(executor);
-    dbg.prepareGetMethod(args, sourceMap);
+    dbg.prepareGetMethod(args, debugInfo);
     const server = Net.createServer((socket) => {
-        const session = new Debuggee_1.TVMDebugSession(dbg);
+        const session = new TVMDebugSession_1.TVMDebugSession(dbg);
         session.setRunAsServer(true);
         session.start(socket, socket);
     }).listen(42069);
@@ -47,12 +48,12 @@ async function debugGetMethod(executor, args, sourceMap) {
     return result;
 }
 exports.debugGetMethod = debugGetMethod;
-async function debugTransaction(executor, args, code, sourceMap) {
+async function debugTransaction(executor, args, code, debugInfo) {
     console.log('Launched transaction debug session. Please connect using the extension.');
     const { dbg, promise } = initDebuggee(executor);
-    dbg.prepareTransaction(args, code, sourceMap);
+    dbg.prepareTransaction(args, code, debugInfo);
     const server = Net.createServer((socket) => {
-        const session = new Debuggee_1.TVMDebugSession(dbg);
+        const session = new TVMDebugSession_1.TVMDebugSession(dbg);
         session.setRunAsServer(true);
         session.start(socket, socket);
     }).listen(42069);

package/dist/executor/Executor.d.ts

@@ -98,6 +98,7 @@ export declare class Executor implements IExecutor {
     destroyTvmEmulator(ptr: number): void;
     sbsGetMethodStep(ptr: number): boolean;
     sbsGetMethodStack(ptr: number): TupleItem[];
+    sbsGetMethodC7(ptr: number): TupleItem;
     sbsGetMethodCodePos(ptr: number): {
         hash: string;
         offset: number;
@@ -114,5 +115,6 @@ export declare class Executor implements IExecutor {
         offset: number;
     };
     sbsTransactionStack(ptr: number): TupleItem[];
+    sbsTransactionC7(ptr: number): TupleItem;
     sbsTransactionResult(ptr: number): EmulationResult;
 }

package/dist/executor/Executor.js

@@ -247,6 +247,12 @@ class Executor {
         ]));
         return (0, core_1.parseTuple)(core_1.Cell.fromBase64(resp));
     }
+    sbsGetMethodC7(ptr) {
+        const resp = this.extractString(this.invoke('_sbs_get_c7', [
+            ptr
+        ]));
+        return (0, core_1.parseTuple)((0, core_1.beginCell)().storeUint(1, 24).storeRef(core_1.Cell.EMPTY).storeSlice(core_1.Cell.fromBase64(resp).beginParse()).endCell())[0];
+    }
     sbsGetMethodCodePos(ptr) {
         const resp = this.extractString(this.invoke('_sbs_get_code_pos', [
             ptr
@@ -305,6 +311,12 @@ class Executor {
         ]));
         return (0, core_1.parseTuple)(core_1.Cell.fromBase64(resp));
     }
+    sbsTransactionC7(ptr) {
+        const resp = this.extractString(this.invoke('_em_sbs_c7', [
+            ptr
+        ]));
+        return (0, core_1.parseTuple)((0, core_1.beginCell)().storeUint(1, 24).storeRef(core_1.Cell.EMPTY).storeSlice(core_1.Cell.fromBase64(resp).beginParse()).endCell())[0];
+    }
     sbsTransactionResult(ptr) {
         const result = JSON.parse(this.extractString(this.invoke('_em_sbs_result', [
             ptr