@tychosdk/disasm 0.1.5 → 0.1.7

package/dist/disasm/fift.js

@@ -1,48 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.disasmToFift = disasmToFift;
-const core_1 = require("@ton/core");
 const structured_1 = require("./structured");
 async function disasmToFift(code, params = {}) {
     const { root, items } = await (0, structured_1.disasmStructured)(code);
-    const codeCells = new CodeCells(code);
+    const codeCells = new structured_1.CodeCells(code);
     const ctx = new Context(items, codeCells, {
         tabWidth: params.tabWidth != null ? params.tabWidth : 2,
     });
     new State(ctx, 0).disasm(ctx.getCode(root));
     return ctx.output;
 }
-class CodeCells {
-    constructor(code) {
-        this.hashToCell = new Map();
-        const stack = [];
-        if (code instanceof core_1.Cell) {
-            stack.push(code);
-        }
-        else {
-            stack.push(core_1.Cell.fromBase64(code));
-        }
-        while (stack.length > 0) {
-            const cell = stack[stack.length - 1];
-            const reprHash = cell.hash(3).toString("hex");
-            if (this.hashToCell.has(reprHash)) {
-                stack.pop();
-            }
-            else {
-                this.hashToCell.set(reprHash, cell);
-                for (const child of cell.refs) {
-                    stack.push(child);
-                }
-            }
-        }
-    }
-    getCell(hash) {
-        const res = this.hashToCell.get(hash);
-        if (res == null)
-            throw new Error("Unknown cell");
-        return res;
-    }
-}
 class State {
     constructor(ctx, depth) {
         this.ctx = ctx;
@@ -50,22 +18,64 @@ class State {
     }
     disasm(block) {
         while (true) {
+            let opcodeBits = 0;
+            let opcodeRefs = 0;
             for (const opcode of block.opcodes) {
                 this.showOp(opcode);
+                opcodeBits += opcode.bits;
+                opcodeRefs += opcode.refs || 0;
             }
             if (block.tail == null) {
+                this.dict = undefined;
+                this.flushCont();
                 break;
             }
             else if (block.tail.type === "incomplete") {
-                this.writeln("Cannot disassemble");
+                this.dict = undefined;
+                this.flushCont();
+                this.showIncompleteTail(block, opcodeBits, opcodeRefs);
                 break;
             }
             else {
                 block = this.ctx.getCode(block.tail.id);
             }
         }
-        this.dict = undefined;
-        this.flushCont();
+    }
+    showIncompleteTail(block, opcodeBits, opcodeRefs) {
+        const cell = this.ctx.getCell(block.cellHash);
+        const bits = cell
+            .asSlice()
+            .skip(block.offsetBits + opcodeBits)
+            .loadBits(block.bits - opcodeBits);
+        this.writeln(`Cannot disassemble: x{${bits.toString()}}`);
+        const stack = [];
+        if (opcodeRefs < block.refs) {
+            stack.push({
+                depth: 1,
+                refs: cell.refs.slice(block.offsetRefs + opcodeRefs, block.offsetRefs + block.refs),
+                index: block.offsetRefs + opcodeRefs,
+            });
+        }
+        const prevDepth = this.depth;
+        this.depth = 0;
+        outer: while (stack.length > 0) {
+            const item = stack[stack.length - 1];
+            while (item.index < item.refs.length) {
+                const child = item.refs[item.index++];
+                const indent = " ".repeat(item.depth);
+                this.writeln(`${indent}x{${child.bits.toString()}}`);
+                if (child.refs.length > 0) {
+                    stack.push({
+                        depth: item.depth + 1,
+                        refs: child.refs,
+                        index: 0,
+                    });
+                    continue outer;
+                }
+            }
+            stack.pop();
+        }
+        this.depth = prevDepth;
     }
     showOp(opcode) {
         // Track consequent dict ops.
@@ -384,20 +394,20 @@ class Context {
                         break;
                     }
                     case "library": {
-                        cellHash = item.hash;
+                        cellHash = item.cellHash;
                         break;
                     }
-                    case "dataBlock": {
+                    case "data": {
                         if (item.data.type !== "cell")
                             throw new Error("Unexpected slice");
-                        cellHash = core_1.Cell.fromBase64(item.data.boc).hash(3).toString("hex");
+                        cellHash = item.data.cellHash;
                         break;
                     }
                     case "jumpTable": {
                         throw new Error("Unexpected jump table");
                     }
                 }
-                return `(${cellHash})`;
+                return `(${cellHash.toUpperCase()})`;
             }
             case "slice": {
                 const item = this.items[arg.id];
@@ -412,12 +422,13 @@ class Context {
                         refCount = item.refs;
                         break;
                     }
-                    case "dataBlock": {
+                    case "data": {
                         if (item.data.type !== "slice")
                             throw new Error("Unexpected cell");
-                        const slice = core_1.Cell.fromBase64(item.data.boc).asSlice();
-                        bits = slice.loadBits(item.data.bits);
-                        refCount = item.data.refs;
+                        const { data } = item;
+                        const cell = this.getCell(data.cellHash);
+                        bits = cell.asSlice().skip(data.offsetBits).loadBits(data.bits);
+                        refCount = data.refs;
                         break;
                     }
                     case "jumpTable": {
@@ -432,7 +443,7 @@ class Context {
                     return `(${bits.toString()},${refCount})`;
                 }
                 else {
-                    return bits.toString();
+                    return `x{${bits.toString()}}`;
                 }
             }
         }

package/dist/disasm/structured.d.ts

@@ -1,4 +1,4 @@
-import { Cell } from "@ton/core";
+import { Cell, Slice } from "@ton/core";
 /**
  * All code parts are referenced by a numberic ID.
  */
@@ -18,7 +18,7 @@ export type Item = ({
     type: "code";
 } & CodeBlock) | ({
     id: number;
-    type: "dataBlock";
+    type: "data";
 } & DataBlock) | ({
     id: number;
     type: "library";
@@ -99,19 +99,25 @@ export type Data = ({
 } & DataCell);
 export type DataType = Data["type"];
 export type DataSlice = {
+    cellHash: string;
     offsetBits: number;
     offsetRefs: number;
     bits: number;
     refs: number;
-    boc: string;
 };
 export type DataCell = {
-    boc: string;
+    cellHash: string;
 };
 export type Library = {
-    hash: string;
+    cellHash: string;
 };
 export declare function disasmStructured(code: Cell | string): Promise<Code>;
+export declare class CodeCells {
+    private hashToCell;
+    constructor(code: Cell | string);
+    getCell(hash: DataCell | DataSlice | Library | JumpTable | CodeBlock | string): Cell;
+    getSlice(slice: DataSlice | CodeBlock): Slice;
+}
 export declare function expectJumpTable(item: Item): asserts item is {
     id: ItemId;
     type: "jumpTable";

package/dist/disasm/structured.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeCells = void 0;
 exports.disasmStructured = disasmStructured;
 exports.expectJumpTable = expectJumpTable;
 exports.expectCont = expectCont;
@@ -15,6 +16,7 @@ exports.expectSliceArg = expectSliceArg;
 exports.expectContArg = expectContArg;
 const core_1 = require("@ton/core");
 const env_1 = require("../env");
+const slice_1 = require("../util/slice");
 async function disasmStructured(code) {
     await (0, env_1.wasmLoaded)();
     let boc;
@@ -28,6 +30,51 @@ async function disasmStructured(code) {
     const parsed = JSON.parse(res);
     return parsed;
 }
+class CodeCells {
+    constructor(code) {
+        this.hashToCell = new Map();
+        if (typeof code === "string") {
+            code = core_1.Cell.fromBase64(code);
+        }
+        const stack = [];
+        const addCell = (cell) => {
+            const reprHash = cell.hash(3).toString("hex");
+            if (this.hashToCell.has(reprHash)) {
+                return false;
+            }
+            this.hashToCell.set(reprHash, cell);
+            if (cell.refs.length > 0) {
+                stack.push({ refs: cell.refs, index: 0 });
+            }
+            return true;
+        };
+        addCell(code);
+        outer: while (stack.length > 0) {
+            const item = stack[stack.length - 1];
+            while (item.index < item.refs.length) {
+                const child = item.refs[item.index++];
+                if (addCell(child)) {
+                    continue outer;
+                }
+            }
+            stack.pop();
+        }
+    }
+    getCell(hash) {
+        if (typeof hash === "object") {
+            hash = hash.cellHash;
+        }
+        const res = this.hashToCell.get(hash);
+        if (res == null)
+            throw new Error("Unknown cell");
+        return res;
+    }
+    getSlice(slice) {
+        const cell = this.getCell(slice);
+        return (0, slice_1.makeSlice)(cell, slice.offsetBits, slice.offsetRefs, slice.bits, slice.refs);
+    }
+}
+exports.CodeCells = CodeCells;
 // === Expect Item ===
 function expectJumpTable(item) {
     if (item.type !== "jumpTable")

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { disasmStructured, expectCellArg, expectCont, expectContArg, expectData, expectDataCell, expectDataSlice, expectIntArg, expectJumpTable, expectLibrary, expectRegArg, expectSliceArg, expectStackArg, Code, CodeBlock, CodeBlockTail, CodeBlockTailType, Data, DataBlock, DataCell, DataSlice, DataType, Item, ItemId, ItemType, JumpTable, Library, Opcode, OpcodeArg, OpcodeArgType, } from "./disasm/structured";
+export { disasmStructured, expectCellArg, expectCont, expectContArg, expectData, expectDataCell, expectDataSlice, expectIntArg, expectJumpTable, expectLibrary, expectRegArg, expectSliceArg, expectStackArg, Code, CodeBlock, CodeBlockTail, CodeBlockTailType, CodeCells, Data, DataBlock, DataCell, DataSlice, DataType, Item, ItemId, ItemType, JumpTable, Library, Opcode, OpcodeArg, OpcodeArgType, } from "./disasm/structured";
 export { disasmToFift } from "./disasm/fift";
 export { makeSlice } from "./util/slice";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSlice = exports.disasmToFift = exports.expectStackArg = exports.expectSliceArg = exports.expectRegArg = exports.expectLibrary = exports.expectJumpTable = exports.expectIntArg = exports.expectDataSlice = exports.expectDataCell = exports.expectData = exports.expectContArg = exports.expectCont = exports.expectCellArg = exports.disasmStructured = void 0;
+exports.makeSlice = exports.disasmToFift = exports.CodeCells = exports.expectStackArg = exports.expectSliceArg = exports.expectRegArg = exports.expectLibrary = exports.expectJumpTable = exports.expectIntArg = exports.expectDataSlice = exports.expectDataCell = exports.expectData = exports.expectContArg = exports.expectCont = exports.expectCellArg = exports.disasmStructured = void 0;
 var structured_1 = require("./disasm/structured");
 Object.defineProperty(exports, "disasmStructured", { enumerable: true, get: function () { return structured_1.disasmStructured; } });
 Object.defineProperty(exports, "expectCellArg", { enumerable: true, get: function () { return structured_1.expectCellArg; } });
@@ -15,6 +15,7 @@ Object.defineProperty(exports, "expectLibrary", { enumerable: true, get: functio
 Object.defineProperty(exports, "expectRegArg", { enumerable: true, get: function () { return structured_1.expectRegArg; } });
 Object.defineProperty(exports, "expectSliceArg", { enumerable: true, get: function () { return structured_1.expectSliceArg; } });
 Object.defineProperty(exports, "expectStackArg", { enumerable: true, get: function () { return structured_1.expectStackArg; } });
+Object.defineProperty(exports, "CodeCells", { enumerable: true, get: function () { return structured_1.CodeCells; } });
 var fift_1 = require("./disasm/fift");
 Object.defineProperty(exports, "disasmToFift", { enumerable: true, get: function () { return fift_1.disasmToFift; } });
 var slice_1 = require("./util/slice");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tychosdk/disasm",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Tycho TVM disasm",
   "main": "dist/index.js",
   "browser": {