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

package/dist/blockchain/Blockchain.d.ts

@@ -98,6 +98,7 @@ export declare class Blockchain {
     protected lock: AsyncLock;
     protected contractFetches: Map<string, Promise<SmartContract>>;
     protected nextCreateWalletIndex: number;
+    protected shouldDebug: boolean;
     readonly executor: IExecutor;
     /**
      * Saves snapshot of current blockchain.
@@ -115,6 +116,8 @@ export declare class Blockchain {
      * @param snapshot Snapshot of blockchain
      */
     loadFrom(snapshot: BlockchainSnapshot): Promise<void>;
+    get debug(): boolean;
+    set debug(value: boolean);
     /**
      * @returns Current time in blockchain
      */

package/dist/blockchain/Blockchain.js

@@ -81,6 +81,12 @@ class Blockchain {
         this.globalLibs = snapshot.libs;
         this.nextCreateWalletIndex = snapshot.nextCreateWalletIndex;
     }
+    get debug() {
+        return this.shouldDebug;
+    }
+    set debug(value) {
+        this.shouldDebug = value;
+    }
     /**
      * @returns Current time in blockchain
      */
@@ -112,6 +118,7 @@ class Blockchain {
         this.lock = new AsyncLock_1.AsyncLock();
         this.contractFetches = new Map();
         this.nextCreateWalletIndex = 0;
+        this.shouldDebug = false;
         this.networkConfig = blockchainConfigToBase64(opts.config);
         this.executor = opts.executor;
         this.storage = opts.storage;

package/dist/blockchain/SmartContract.d.ts

@@ -98,4 +98,6 @@ export declare class SmartContract {
     get verbosity(): LogsVerbosity;
     set verbosity(value: LogsVerbosity);
     setVerbosity(verbosity: Partial<LogsVerbosity> | Verbosity | undefined): void;
+    get debug(): boolean;
+    setDebug(debug: boolean | undefined): void;
 }

package/dist/blockchain/SmartContract.js

@@ -10,11 +10,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SmartContract_account, _SmartContract_parsedAccount, _SmartContract_lastTxTime, _SmartContract_verbosity;
+var _SmartContract_account, _SmartContract_parsedAccount, _SmartContract_lastTxTime, _SmartContract_verbosity, _SmartContract_debug;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartContract = exports.EmulationError = exports.TimeError = exports.GetMethodError = exports.createEmptyShardAccount = exports.createShardAccount = void 0;
 const core_1 = require("@ton/core");
 const selector_1 = require("../utils/selector");
+const debug_1 = require("../debugger/debug");
+const SourceMapCache_1 = require("../debugger/SourceMapCache");
 function createShardAccount(args) {
     let wc = args.workchain ?? 0;
     let address = args.address ?? (0, core_1.contractAddress)(wc, { code: args.code, data: args.data });
@@ -128,6 +130,7 @@ class SmartContract {
         _SmartContract_parsedAccount.set(this, void 0);
         _SmartContract_lastTxTime.set(this, void 0);
         _SmartContract_verbosity.set(this, void 0);
+        _SmartContract_debug.set(this, void 0);
         this.address = shardAccount.account.addr;
         __classPrivateFieldSet(this, _SmartContract_account, (0, core_1.beginCell)().store((0, core_1.storeShardAccount)(shardAccount)).endCell().toBoc().toString('base64'), "f");
         __classPrivateFieldSet(this, _SmartContract_parsedAccount, shardAccount, "f");
@@ -210,10 +213,34 @@ class SmartContract {
             now: this.blockchain.now,
             ...params,
         };
-        return await this.runCommon(() => this.blockchain.executor.runTransaction({
+        const args = {
             ...this.createCommonArgs(params),
             message: (0, core_1.beginCell)().store((0, core_1.storeMessage)(message)).endCell(),
-        }));
+        };
+        if (this.debug) {
+            const acc = this.account;
+            if (acc.account === undefined || acc.account === null) {
+                console.log('Debugging uninitialized accounts is unsupported in debugger beta');
+                return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
+            }
+            if (acc.account.storage.state.type !== 'active') {
+                console.log('Debugging uninitialized accounts is unsupported in debugger beta');
+                return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
+            }
+            const code = acc.account.storage.state.state.code;
+            if (code === undefined || code === null) {
+                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'));
+            if (sm === undefined) {
+                return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
+            }
+            return await this.runCommon(() => (0, debug_1.debugTransaction)(this.blockchain.executor, args, code, sm));
+        }
+        else {
+            return await this.runCommon(() => this.blockchain.executor.runTransaction(args));
+        }
     }
     async runTickTock(which, params) {
         return await this.runCommon(() => this.blockchain.executor.runTickTock({
@@ -250,7 +277,7 @@ class SmartContract {
         if (this.account.account?.storage.state.type !== 'active') {
             throw new Error('Trying to run get method on non-active contract');
         }
-        const res = await this.blockchain.executor.runGetMethod({
+        const args = {
             code: this.account.account?.storage.state.state.code,
             data: this.account.account?.storage.state.state.data,
             methodId: typeof method === 'string' ? (0, selector_1.getSelectorForMethod)(method) : method,
@@ -264,7 +291,20 @@ class SmartContract {
             randomSeed: params?.randomSeed ?? Buffer.alloc(32),
             gasLimit: params?.gasLimit ?? 10000000n,
             debugEnabled: this.verbosity.debugLogs,
-        });
+        };
+        let res;
+        if (this.debug) {
+            const sm = SourceMapCache_1.defaultSourceMapCache.get(args.code.hash().toString('base64'));
+            if (sm === undefined) {
+                res = await this.blockchain.executor.runGetMethod(args);
+            }
+            else {
+                res = await (0, debug_1.debugGetMethod)(this.blockchain.executor, args, sm);
+            }
+        }
+        else {
+            res = await this.blockchain.executor.runGetMethod(args);
+        }
         if (this.verbosity.print && this.verbosity.blockchainLogs && res.logs.length > 0) {
             console.log(res.logs);
         }
@@ -312,6 +352,12 @@ class SmartContract {
             __classPrivateFieldSet(this, _SmartContract_verbosity, verbosity, "f");
         }
     }
+    get debug() {
+        return __classPrivateFieldGet(this, _SmartContract_debug, "f") ?? this.blockchain.debug;
+    }
+    setDebug(debug) {
+        __classPrivateFieldSet(this, _SmartContract_debug, debug, "f");
+    }
 }
 exports.SmartContract = SmartContract;
-_SmartContract_account = new WeakMap(), _SmartContract_parsedAccount = new WeakMap(), _SmartContract_lastTxTime = new WeakMap(), _SmartContract_verbosity = new WeakMap();
+_SmartContract_account = new WeakMap(), _SmartContract_parsedAccount = new WeakMap(), _SmartContract_lastTxTime = new WeakMap(), _SmartContract_verbosity = new WeakMap(), _SmartContract_debug = new WeakMap();

package/dist/debugger/Debuggee.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+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 = {
+    path: string;
+    line: number;
+    variables: string[];
+};
+export type SourceMap = {
+    [k: number]: SourceMapEntry;
+};
+type Breakpoint = {
+    id: number;
+    line: number;
+    verified: boolean;
+};
+export declare class Debuggee extends EventEmitter {
+    executor: Executor;
+    ptr: number;
+    debugType: 'get' | 'tx';
+    sourceMap: SourceMap;
+    availableLines: {
+        [k: string]: number[];
+    };
+    codeCells: Map<string, Cell>;
+    breakpoints: Map<string, Breakpoint[]>;
+    breakpointID: number;
+    frames: string[];
+    finishedCallback: (v: any) => void;
+    constructor(executor: Executor, finishedCallback: (v: any) => void);
+    setCodeCells(code: Cell): void;
+    setSourceMap(sourceMap: SourceMap): void;
+    getAvailableSourcePaths(): string[];
+    getAvailableLines(path: string): number[];
+    isLineAvailable(path: string, line: number): boolean;
+    continue(): void;
+    step(stopEvent?: string): void;
+    startGetMethod(args: GetMethodArgs): void;
+    startTransaction(args: RunTransactionArgs): void;
+    vmStep(): boolean;
+    codePos(): {
+        hash: string;
+        offset: number;
+    };
+    getStack(): TupleItem[];
+    currentDebugInfoNumber(): number | undefined;
+    currentSourceMapEntry(): SourceMapEntry | undefined;
+    breakpointKey(path: string, line: number): string;
+    splitBreakpointKey(k: string): {
+        path: string;
+        line: number;
+    };
+    clearBreakpoints(path: string): void;
+    hasBreakpoint(path: string, line: number): boolean;
+    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;
+    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 {};