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

package/dist/blockchain/SmartContract.js

@@ -16,7 +16,7 @@ exports.SmartContract = exports.EmulationError = exports.TimeError = exports.Get
 const core_1 = require("@ton/core");
 const selector_1 = require("../utils/selector");
 const debug_1 = require("../debugger/debug");
-const SourceMapCache_1 = require("../debugger/SourceMapCache");
+const DebugInfoCache_1 = require("../debugger/DebugInfoCache");
 function createShardAccount(args) {
     let wc = args.workchain ?? 0;
     let address = args.address ?? (0, core_1.contractAddress)(wc, { code: args.code, data: args.data });
@@ -232,7 +232,7 @@ class SmartContract {
                 console.log('Debugging uninitialized accounts is unsupported in debugger beta');
                 return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
             }
-            const sm = SourceMapCache_1.defaultSourceMapCache.get(code.hash().toString('base64'));
+            const sm = DebugInfoCache_1.defaultDebugInfoCache.get(code.hash().toString('base64'));
             if (sm === undefined) {
                 return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
             }
@@ -294,12 +294,12 @@ class SmartContract {
         };
         let res;
         if (this.debug) {
-            const sm = SourceMapCache_1.defaultSourceMapCache.get(args.code.hash().toString('base64'));
-            if (sm === undefined) {
+            const di = DebugInfoCache_1.defaultDebugInfoCache.get(args.code.hash().toString('base64'));
+            if (di === undefined) {
                 res = await this.blockchain.executor.runGetMethod(args);
             }
             else {
-                res = await (0, debug_1.debugGetMethod)(this.blockchain.executor, args, sm);
+                res = await (0, debug_1.debugGetMethod)(this.blockchain.executor, args, di);
             }
         }
         else {

package/dist/debugger/DebugInfoCache.d.ts

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

package/dist/debugger/DebugInfoCache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompiledContract = exports.defaultDebugInfoCache = void 0;
+const node_path_1 = require("node:path");
+exports.defaultDebugInfoCache = 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 { locations, globals } = c.debugInfo;
+    const sm = {};
+    for (let i = 0; i < locations.length; i++) {
+        const di = locations[i];
+        const common = {
+            path: (0, node_path_1.resolve)(di.file),
+            line: di.line,
+            function: di.func,
+        };
+        if (di.ret) {
+            sm[i] = {
+                ...common,
+                type: 'return',
+            };
+        }
+        else if (di.is_catch) {
+            sm[i] = {
+                ...common,
+                type: 'catch',
+            };
+        }
+        else {
+            sm[i] = {
+                ...common,
+                type: 'statement',
+                variables: di.vars ?? [],
+                firstStatement: di.first_stmt,
+            };
+        }
+    }
+    exports.defaultDebugInfoCache.set(c.code.hash().toString('base64'), {
+        sourceMap: sm,
+        globals,
+    });
+    return c.code;
+}
+exports.registerCompiledContract = registerCompiledContract;

package/dist/debugger/Debuggee.d.ts

@@ -2,21 +2,43 @@
 import EventEmitter from 'node:events';
 import { Executor, GetMethodArgs, RunTransactionArgs } from '../executor/Executor';
 import { Cell, TupleItem } from '@ton/core';
-import { LoggingDebugSession } from '@vscode/debugadapter';
-import { DebugProtocol } from '@vscode/debugprotocol';
-export type SourceMapEntry = {
+export type SourceMapEntry = ({
     path: string;
     line: number;
+    function: string;
+}) & ({
+    type: 'statement';
     variables: string[];
-};
+    firstStatement?: true;
+} | {
+    type: 'return';
+} | {
+    type: 'catch';
+});
 export type SourceMap = {
     [k: number]: SourceMapEntry;
 };
+export type GlobalEntry = {
+    name: string;
+};
+export type DebugInfo = {
+    sourceMap: SourceMap;
+    globals: GlobalEntry[];
+};
 type Breakpoint = {
     id: number;
     line: number;
     verified: boolean;
 };
+export type Variable = {
+    name: string;
+    value: TupleItem;
+};
+type StackFrame = {
+    function: string;
+    path: string;
+    line: number;
+};
 export declare class Debuggee extends EventEmitter {
     executor: Executor;
     ptr: number;
@@ -28,24 +50,34 @@ export declare class Debuggee extends EventEmitter {
     codeCells: Map<string, Cell>;
     breakpoints: Map<string, Breakpoint[]>;
     breakpointID: number;
-    frames: string[];
+    frames: StackFrame[];
+    globals: GlobalEntry[];
     finishedCallback: (v: any) => void;
     constructor(executor: Executor, finishedCallback: (v: any) => void);
     setCodeCells(code: Cell): void;
+    setDebugInfo(debugInfo: DebugInfo): void;
     setSourceMap(sourceMap: SourceMap): void;
+    setGlobals(globals: GlobalEntry[]): void;
     getAvailableSourcePaths(): string[];
     getAvailableLines(path: string): number[];
     isLineAvailable(path: string, line: number): boolean;
     continue(): void;
-    step(stopEvent?: string): void;
+    stepIn(): void;
+    stepOver(): void;
+    stepOut(): void;
     startGetMethod(args: GetMethodArgs): void;
     startTransaction(args: RunTransactionArgs): void;
+    getC7(): TupleItem;
     vmStep(): boolean;
     codePos(): {
         hash: string;
         offset: number;
     };
     getStack(): TupleItem[];
+    getContParam(): number;
+    setContParam(param: number): number;
+    getLocalVariables(): Variable[] | undefined;
+    getGlobalVariables(): Variable[] | undefined;
     currentDebugInfoNumber(): number | undefined;
     currentSourceMapEntry(): SourceMapEntry | undefined;
     breakpointKey(path: string, line: number): string;
@@ -58,31 +90,19 @@ export declare class Debuggee extends EventEmitter {
     setBreakpoint(path: string, line: number): Breakpoint;
     sendEvent(event: string, ...args: any[]): void;
     onFinished(): void;
-    stepUntilLine(breakpointsOnly: boolean, stopEvent?: string): void;
-    prepareGetMethod(args: GetMethodArgs, sourceMap: SourceMap): void;
-    prepareTransaction(args: RunTransactionArgs, code: Cell, sourceMap: SourceMap): void;
+    stackFrames(): StackFrame[];
+    stepUntil(what: {
+        type: 'breakpoint';
+    } | {
+        type: 'any-line';
+        stopEvent: 'stopOnBreakpoint' | 'stopOnStep';
+    } | {
+        type: 'next-line';
+    } | {
+        type: 'out';
+    }): void;
+    prepareGetMethod(args: GetMethodArgs, debugInfo: DebugInfo): void;
+    prepareTransaction(args: RunTransactionArgs, code: Cell, debugInfo: DebugInfo): void;
     start(debug: boolean, stopOnEntry: boolean): void;
 }
-export declare class TVMDebugSession extends LoggingDebugSession {
-    static readonly threadID = 1;
-    static readonly stackFrameID = 1;
-    static readonly variablesReference = 1;
-    debuggee: Debuggee;
-    constructor(debuggee: Debuggee);
-    protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void;
-    protected loadedSourcesRequest(response: DebugProtocol.LoadedSourcesResponse, args: DebugProtocol.LoadedSourcesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected breakpointLocationsRequest(response: DebugProtocol.BreakpointLocationsResponse, args: DebugProtocol.BreakpointLocationsArguments, request?: DebugProtocol.Request | undefined): void;
-    protected launchRequest(response: DebugProtocol.LaunchResponse, args: DebugProtocol.LaunchRequestArguments, request?: DebugProtocol.Request | undefined): void;
-    protected attachRequest(response: DebugProtocol.AttachResponse, args: DebugProtocol.AttachRequestArguments, request?: DebugProtocol.Request | undefined): void;
-    protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments, request?: DebugProtocol.Request | undefined): void;
-    protected threadsRequest(response: DebugProtocol.ThreadsResponse, request?: DebugProtocol.Request | undefined): void;
-    protected continueRequest(response: DebugProtocol.ContinueResponse, args: DebugProtocol.ContinueArguments, request?: DebugProtocol.Request | undefined): void;
-    protected nextRequest(response: DebugProtocol.NextResponse, args: DebugProtocol.NextArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stepInRequest(response: DebugProtocol.StepInResponse, args: DebugProtocol.StepInArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stepOutRequest(response: DebugProtocol.StepOutResponse, args: DebugProtocol.StepOutArguments, request?: DebugProtocol.Request | undefined): void;
-    protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments, request?: DebugProtocol.Request | undefined): void;
-    protected scopesRequest(response: DebugProtocol.ScopesResponse, args: DebugProtocol.ScopesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments, request?: DebugProtocol.Request | undefined): void;
-    protected disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments, request?: DebugProtocol.Request | undefined): void;
-}
 export {};