@tychosdk/disasm 0.1.3 → 0.1.5

package/dist/disasm/fift.d.ts

@@ -0,0 +1,4 @@
+import { Cell } from "@ton/core";
+export declare function disasmToFift(code: Cell | string, params?: {
+    tabWidth?: number;
+}): Promise<string>;

package/dist/disasm/fift.js

@@ -0,0 +1,460 @@
+"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 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;
+        this.depth = depth;
+    }
+    disasm(block) {
+        while (true) {
+            for (const opcode of block.opcodes) {
+                this.showOp(opcode);
+            }
+            if (block.tail == null) {
+                break;
+            }
+            else if (block.tail.type === "incomplete") {
+                this.writeln("Cannot disassemble");
+                break;
+            }
+            else {
+                block = this.ctx.getCode(block.tail.id);
+            }
+        }
+        this.dict = undefined;
+        this.flushCont();
+    }
+    showOp(opcode) {
+        // Track consequent dict ops.
+        switch (opcode.name) {
+            case "DICTPUSHCONST": {
+                const [n, dict] = opcode.args;
+                (0, structured_1.expectIntArg)(n);
+                (0, structured_1.expectSliceArg)(dict);
+                this.flushCont();
+                this.dict = this.ctx.getJumpTable(dict.id);
+                this.showSimpleOp(opcode);
+                return;
+            }
+            case "DICTIGETJMP":
+            case "DICTIGETJMPZ":
+            case "DICTUGETJMP":
+            case "DICTUGETJMPZ":
+            case "DICTIGETEXEC":
+            case "DICTUGETEXEC": {
+                if (this.dict != null) {
+                    this.flushCont();
+                    this.showConstDictOp(opcode);
+                    return;
+                }
+                break;
+            }
+        }
+        // Reset dict.
+        this.dict = undefined;
+        // Track consequent cont ops.
+        switch (opcode.name) {
+            case "PUSHCONT":
+            case "PUSHREFCONT": {
+                const [cont] = opcode.args;
+                (0, structured_1.expectContArg)(cont);
+                this.saveContBody(this.ctx.getCode(cont.id));
+                return;
+            }
+            case "REPEAT":
+            case "UNTIL":
+            case "IF":
+            case "IFNOT":
+            case "IFJMP":
+            case "IFNOTJMP": {
+                if (this.contX != null) {
+                    this.flushContY();
+                    this.showContOp(opcode.name);
+                    return;
+                }
+                break;
+            }
+            case "IFREF":
+            case "IFNOTREF":
+            case "IFJMPREF":
+            case "IFNOTJMPREF":
+            case "CALLREF":
+            case "JMPREF": {
+                this.flushCont();
+                this.showRefOp(opcode);
+                return;
+            }
+            case "WHILE": {
+                if (this.contY != null) {
+                    this.showCont2Op("WHILE", "DO");
+                    return;
+                }
+                break;
+            }
+            case "IFELSE": {
+                if (this.contY != null) {
+                    this.showCont2Op("IF", "ELSE");
+                    return;
+                }
+                break;
+            }
+            case "IFREFELSE": {
+                if (this.contX != null) {
+                    this.showContRefOp(opcode, "IF", "ELSE", false);
+                    return;
+                }
+                break;
+            }
+            case "IFELSEREF": {
+                if (this.contX != null) {
+                    this.showContRefOp(opcode, "IF", "ELSE", true);
+                    return;
+                }
+                break;
+            }
+            case "IFREFELSEREF": {
+                this.showRef2Op(opcode, "IF", "ELSE");
+                return;
+            }
+        }
+        // Fallback to simple opcode.
+        this.flushCont();
+        this.showSimpleOp(opcode);
+    }
+    showSimpleOp(opcode) {
+        opcode = this.adjustOpcode(opcode);
+        let args = "";
+        if (opcode.args != null) {
+            for (const arg of opcode.args) {
+                args += `${this.ctx.argToString(arg)} `;
+            }
+        }
+        this.writeln(`${args}${opcode.name}`);
+    }
+    adjustOpcode(opcode) {
+        switch (opcode.name) {
+            case "SETCP0": {
+                if (opcode.args == null || opcode.args.length === 0) {
+                    return {
+                        ...opcode,
+                        name: "SETCP",
+                        args: [{ type: "int", value: "0" }],
+                    };
+                }
+                break;
+            }
+            case "XCHG": {
+                if (opcode.args != null && opcode.args.length === 1) {
+                    return {
+                        ...opcode,
+                        args: [{ type: "stack", idx: 0 }, ...opcode.args],
+                    };
+                }
+                break;
+            }
+            case "LSHIFT": {
+                if (opcode.args != null && opcode.args.length > 0) {
+                    return {
+                        ...opcode,
+                        name: "LSHIFT#",
+                    };
+                }
+                break;
+            }
+            case "RSHIFT": {
+                if (opcode.args != null && opcode.args.length > 0) {
+                    return {
+                        ...opcode,
+                        name: "RSHIFT#",
+                    };
+                }
+                break;
+            }
+        }
+        // Fallback to the original.
+        return opcode;
+    }
+    showRefOp(opcode) {
+        this.flushCont();
+        const [ref] = opcode.args;
+        (0, structured_1.expectCellArg)(ref);
+        this.writeln(`${opcode.name.slice(0, -3)}:<{`);
+        this.depth += 1;
+        this.disasm(this.ctx.getCode(ref.id));
+        this.depth -= 1;
+        this.writeln("}>");
+        if (this.contX != null) {
+            throw new Error("Invalid cont state");
+        }
+    }
+    showContRefOp(opcode, prefix, infix, firstIsCont) {
+        this.flushContY();
+        const [ref] = opcode.args;
+        (0, structured_1.expectCellArg)(ref);
+        this.writeln(`${prefix}:<{`);
+        if (this.contX == null)
+            throw new Error("Inconsistent contX state");
+        const branches = [this.ctx.getCode(ref.id), this.contX];
+        this.contX = undefined;
+        this.depth += 1;
+        this.disasm(branches[+firstIsCont]);
+        this.depth -= 1;
+        this.writeln(`}>${infix}<{`);
+        this.depth += 1;
+        this.disasm(branches[+!firstIsCont]);
+        this.depth -= 1;
+        this.writeln("}>");
+    }
+    showRef2Op(opcode, prefix, infix) {
+        this.flushCont();
+        const [ref1, ref2] = opcode.args;
+        (0, structured_1.expectCellArg)(ref1);
+        (0, structured_1.expectCellArg)(ref2);
+        this.writeln(`${prefix}:<{`);
+        this.depth += 1;
+        this.disasm(this.ctx.getCode(ref1.id));
+        this.depth -= 1;
+        this.writeln(`}>${infix}<{`);
+        this.depth += 1;
+        this.disasm(this.ctx.getCode(ref2.id));
+        this.depth -= 1;
+        this.writeln("}>");
+        if (this.contX != null) {
+            throw new Error("Invalid cont state");
+        }
+    }
+    showContOp(prefix) {
+        this.showContBody(prefix, ":<{");
+        this.writeln("}>");
+        if (this.contX != null) {
+            throw new Error("Invalid cont state");
+        }
+    }
+    showCont2Op(prefix, infix) {
+        this.swapCont();
+        this.showContBody(prefix, ":<{");
+        this.swapCont();
+        this.showContBody(`}>${infix}`, "<{");
+        this.writeln("}>");
+        if (this.contX != null || this.contY != null) {
+            throw new Error("Invalid cont state");
+        }
+    }
+    showConstDictOp(opcode) {
+        this.flushCont();
+        if (this.dict == null)
+            throw new Error("Inconsistent dict state");
+        const dictItems = Object.entries(this.dict.items).map(([key, value]) => ({
+            key: BigInt(key),
+            value,
+        }));
+        dictItems.sort(({ key: a }, { key: b }) => (a < b ? -1 : a > b ? 1 : 0));
+        if (dictItems.length === 0) {
+            this.writeln(`${opcode.name} {}`);
+        }
+        else {
+            this.writeln(`${opcode.name} {`);
+            this.depth += 1;
+            for (const item of dictItems) {
+                this.writeln(`${item.key} => <{`);
+                new State(this.ctx, this.depth + 1).disasm(this.ctx.getCode(item.value));
+                this.writeln("}>");
+            }
+            this.depth -= 1;
+            this.writeln("}");
+        }
+        this.dict = undefined;
+    }
+    showContBody(prefix, paren) {
+        if (this.contX == null)
+            throw new Error("Inconsistent contX state");
+        this.writeln(`${prefix}${paren}`);
+        new State(this.ctx, this.depth + 1).disasm(this.contX);
+        this.contX = undefined;
+    }
+    flushContX() {
+        if (this.contX != null) {
+            this.showContOp("CONT");
+        }
+    }
+    flushContY() {
+        if (this.contY != null) {
+            this.swapCont();
+            this.showContOp("CONT");
+            this.swapCont();
+        }
+    }
+    flushCont() {
+        this.flushContY();
+        this.flushContX();
+    }
+    saveContBody(cont) {
+        this.flushContY();
+        this.contY = cont;
+        this.swapCont();
+    }
+    swapCont() {
+        const contY = this.contY;
+        this.contY = this.contX;
+        this.contX = contY;
+    }
+    writeln(data) {
+        this.ctx.writeln(this.depth, data);
+    }
+}
+class Context {
+    constructor(items, cells, params) {
+        this.items = items;
+        this.cells = cells;
+        this.string = "";
+        this.tab = " ".repeat(params.tabWidth);
+    }
+    get output() {
+        return this.string;
+    }
+    writeln(indent, data) {
+        this.string += `${this.tab.repeat(indent)}${data}\n`;
+    }
+    argToString(arg) {
+        switch (arg.type) {
+            case "int":
+                return arg.value;
+            case "stack": {
+                if (arg.idx < 0) {
+                    return `s(${arg.idx})`;
+                }
+                else {
+                    return `s${arg.idx}`;
+                }
+            }
+            case "reg": {
+                return `c${arg.idx}`;
+            }
+            case "cell": {
+                const item = this.items[arg.id];
+                let cellHash;
+                switch (item.type) {
+                    case "code": {
+                        if (item.isInline)
+                            throw new Error("Unexpected inline cont");
+                        cellHash = item.cellHash;
+                        break;
+                    }
+                    case "library": {
+                        cellHash = item.hash;
+                        break;
+                    }
+                    case "dataBlock": {
+                        if (item.data.type !== "cell")
+                            throw new Error("Unexpected slice");
+                        cellHash = core_1.Cell.fromBase64(item.data.boc).hash(3).toString("hex");
+                        break;
+                    }
+                    case "jumpTable": {
+                        throw new Error("Unexpected jump table");
+                    }
+                }
+                return `(${cellHash})`;
+            }
+            case "slice": {
+                const item = this.items[arg.id];
+                let bits;
+                let refCount;
+                switch (item.type) {
+                    case "code": {
+                        if (!item.isInline)
+                            throw new Error("Unexpected non-inline cont");
+                        const cell = this.getCell(item.cellHash);
+                        bits = cell.asSlice().skip(item.offsetBits).loadBits(item.bits);
+                        refCount = item.refs;
+                        break;
+                    }
+                    case "dataBlock": {
+                        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;
+                        break;
+                    }
+                    case "jumpTable": {
+                        // NOTE: Jump table is always shown like this.
+                        return "(xC_)";
+                    }
+                    case "library": {
+                        throw new Error("Unexpected library cell");
+                    }
+                }
+                if (refCount > 0) {
+                    return `(${bits.toString()},${refCount})`;
+                }
+                else {
+                    return bits.toString();
+                }
+            }
+        }
+    }
+    getCell(hash) {
+        return this.cells.getCell(hash);
+    }
+    getCode(id) {
+        const item = this.items[id];
+        if (item.type === "library") {
+            throw new Error("Library cells are not supported for now");
+        }
+        else if (item.type !== "code") {
+            throw new Error(`Unexpected item: ${item.type}`);
+        }
+        return item;
+    }
+    getJumpTable(id) {
+        const item = this.items[id];
+        if (item.type !== "jumpTable") {
+            throw new Error(`Unexpected item: ${item.type}`);
+        }
+        return item;
+    }
+}

package/dist/disasm/structured.d.ts

@@ -0,0 +1,160 @@
+import { Cell } from "@ton/core";
+/**
+ * All code parts are referenced by a numberic ID.
+ */
+export type ItemId = number;
+/**
+ * Code is a group of parsed parts and an index from which to start.
+ */
+export type Code = {
+    root: ItemId;
+    items: Item[];
+};
+export type Item = ({
+    id: number;
+    type: "jumpTable";
+} & JumpTable) | ({
+    id: number;
+    type: "code";
+} & CodeBlock) | ({
+    id: number;
+    type: "dataBlock";
+} & DataBlock) | ({
+    id: number;
+    type: "library";
+} & Library);
+export type ItemType = Item["type"];
+/**
+ * Jump table is a dictionary which maps int to some continuations.
+ */
+export type JumpTable = {
+    cellHash: string;
+    keyBits: number;
+    items: Record<string, ItemId>;
+    isFullCode: boolean;
+};
+/**
+ * Parsed continuation.
+ */
+export type CodeBlock = {
+    cellHash: string;
+    isInline: boolean;
+    offsetBits: number;
+    offsetRefs: number;
+    bits: number;
+    refs: number;
+    opcodes: Opcode[];
+    tail?: CodeBlockTail;
+};
+/**
+ * What follows the continuation.
+ */
+export type CodeBlockTail = {
+    type: "incomplete";
+} | {
+    type: "child";
+    id: ItemId;
+};
+export type CodeBlockTailType = CodeBlockTail["type"];
+/**
+ * Parsed opcode.
+ */
+export type Opcode = {
+    bits: number;
+    refs?: number;
+    name: string;
+    args?: OpcodeArg[];
+    gas: number;
+};
+/**
+ * Parsed opcode argument.
+ */
+export type OpcodeArg = {
+    type: "int";
+    value: string;
+} | {
+    type: "stack";
+    idx: number;
+} | {
+    type: "reg";
+    idx: number;
+} | {
+    type: "cell";
+    id: ItemId;
+} | {
+    type: "slice";
+    id: ItemId;
+};
+export type OpcodeArgType = OpcodeArg["type"];
+/**
+ * Cell tree parts that are treated as data.
+ */
+export type DataBlock = {
+    data: Data;
+};
+export type Data = ({
+    type: "slice";
+} & DataSlice) | ({
+    type: "cell";
+} & DataCell);
+export type DataType = Data["type"];
+export type DataSlice = {
+    offsetBits: number;
+    offsetRefs: number;
+    bits: number;
+    refs: number;
+    boc: string;
+};
+export type DataCell = {
+    boc: string;
+};
+export type Library = {
+    hash: string;
+};
+export declare function disasmStructured(code: Cell | string): Promise<Code>;
+export declare function expectJumpTable(item: Item): asserts item is {
+    id: ItemId;
+    type: "jumpTable";
+} & JumpTable;
+export declare function expectCont(item: Item): asserts item is {
+    id: ItemId;
+    type: "code";
+} & CodeBlock;
+export declare function expectLibrary(item: Item): asserts item is {
+    id: ItemId;
+    type: "library";
+} & Library;
+export declare function expectData(item: Item): asserts item is {
+    id: ItemId;
+    type: "data";
+} & Data;
+export declare function expectDataSlice(item: Data): asserts item is {
+    type: "slice";
+} & DataSlice;
+export declare function expectDataCell(item: Data): asserts item is {
+    type: "cell";
+} & DataCell;
+export declare function expectIntArg(opcode: OpcodeArg): asserts opcode is {
+    type: "int";
+    value: "string";
+};
+export declare function expectStackArg(opcode: OpcodeArg): asserts opcode is {
+    type: "stack";
+    idx: number;
+};
+export declare function expectRegArg(opcode: OpcodeArg): asserts opcode is {
+    type: "reg";
+    idx: number;
+};
+export declare function expectCellArg(opcode: OpcodeArg): asserts opcode is {
+    type: "cell";
+    id: ItemId;
+};
+export declare function expectSliceArg(opcode: OpcodeArg): asserts opcode is {
+    type: "slice";
+    id: ItemId;
+};
+export declare function expectContArg(opcode: OpcodeArg): asserts opcode is {
+    type: "cell" | "slice";
+    id: ItemId;
+};

package/dist/disasm/structured.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disasmStructured = disasmStructured;
+exports.expectJumpTable = expectJumpTable;
+exports.expectCont = expectCont;
+exports.expectLibrary = expectLibrary;
+exports.expectData = expectData;
+exports.expectDataSlice = expectDataSlice;
+exports.expectDataCell = expectDataCell;
+exports.expectIntArg = expectIntArg;
+exports.expectStackArg = expectStackArg;
+exports.expectRegArg = expectRegArg;
+exports.expectCellArg = expectCellArg;
+exports.expectSliceArg = expectSliceArg;
+exports.expectContArg = expectContArg;
+const core_1 = require("@ton/core");
+const env_1 = require("../env");
+async function disasmStructured(code) {
+    await (0, env_1.wasmLoaded)();
+    let boc;
+    if (code instanceof core_1.Cell) {
+        boc = code.toBoc({ idx: false }).toString("base64");
+    }
+    else {
+        boc = code;
+    }
+    const res = env_1.wasm.disasm_structured(boc);
+    const parsed = JSON.parse(res);
+    return parsed;
+}
+// === Expect Item ===
+function expectJumpTable(item) {
+    if (item.type !== "jumpTable")
+        throw new Error("Expected jump table item");
+}
+function expectCont(item) {
+    if (item.type !== "code")
+        throw new Error("Expected code item");
+}
+function expectLibrary(item) {
+    if (item.type !== "code")
+        throw new Error("Expected library item");
+}
+function expectData(item) {
+    if (item.type !== "code")
+        throw new Error("Expected data item");
+}
+// === Expect Data ===
+function expectDataSlice(item) {
+    if (item.type !== "slice")
+        throw new Error("Expected slice data");
+}
+function expectDataCell(item) {
+    if (item.type !== "cell")
+        throw new Error("Expected cell data");
+}
+// === Expect Opcode Arg ===
+function expectIntArg(opcode) {
+    if (opcode.type !== "int")
+        throw new Error("Expected int arg");
+}
+function expectStackArg(opcode) {
+    if (opcode.type !== "stack")
+        throw new Error("Expected stack arg");
+}
+function expectRegArg(opcode) {
+    if (opcode.type !== "reg")
+        throw new Error("Expected reg arg");
+}
+function expectCellArg(opcode) {
+    if (opcode.type !== "cell")
+        throw new Error("Expected cell arg");
+}
+function expectSliceArg(opcode) {
+    if (opcode.type !== "slice")
+        throw new Error("Expected slice arg");
+}
+function expectContArg(opcode) {
+    if (opcode.type !== "cell" && opcode.type !== "slice")
+        throw new Error("Expected slice arg");
+}

package/dist/index.d.ts

@@ -1,110 +1,3 @@
-import { Cell } from "@ton/core";
-/**
- * All code parts are referenced by a numberic ID.
- */
-export type ItemId = number;
-/**
- * Code is a group of parsed parts and an index from which to start.
- */
-export type Code = {
-    root: ItemId;
-    items: Item[];
-};
-export type Item = ({
-    id: number;
-    type: "jumpTable";
-} & JumpTable) | ({
-    id: number;
-    type: "code";
-} & CodeBlock) | ({
-    id: number;
-    type: "dataBlock";
-} & DataBlock) | ({
-    id: number;
-    type: "library";
-} & Library);
-export type ItemType = Item["type"];
-/**
- * Jump table is a dictionary which maps int to some continuations.
- */
-export type JumpTable = {
-    cellHash: string;
-    keyBits: number;
-    items: Record<string, ItemId>;
-    isFullCode: boolean;
-};
-/**
- * Parsed continuation.
- */
-export type CodeBlock = {
-    cellHash: string;
-    isInline: boolean;
-    offsetBits: number;
-    offsetRefs: number;
-    bits: number;
-    refs: number;
-    opcodes: Opcode[];
-    tail?: CodeBlockTail;
-};
-/**
- * What follows the continuation.
- */
-export type CodeBlockTail = {
-    type: "incomplete";
-} | {
-    type: "child";
-    id: ItemId;
-};
-export type CodeBlockTailType = CodeBlockTail["type"];
-/**
- * Parsed opcode.
- */
-export type Opcode = {
-    bits: number;
-    refs?: number;
-    name: string;
-    args: OpcodeArg[];
-    gas: number;
-};
-/**
- * Parsed opcode argument.
- */
-export type OpcodeArg = {
-    type: "int";
-    value: string;
-} | {
-    type: "stack";
-    idx: number;
-} | {
-    type: "reg";
-    idx: number;
-} | {
-    type: "cell";
-    id: ItemId;
-} | {
-    type: "slice";
-    id: ItemId;
-};
-export type OpcodeArgType = OpcodeArg["type"];
-/**
- * Cell tree parts that are treated as data.
- */
-export type DataBlock = {
-    data: Data;
-};
-export type Data = {
-    type: "slice";
-    offsetBits: number;
-    offsetRefs: number;
-    bits: number;
-    refs: number;
-    boc: string;
-} | {
-    type: "cell";
-    boc: string;
-};
-export type DataType = Data["type"];
-export type Library = {
-    hash: string;
-};
-export declare function disasmStructured(code: Cell | string): Promise<Code>;
+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 { disasmToFift } from "./disasm/fift";
+export { makeSlice } from "./util/slice";

package/dist/index.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disasmStructured = disasmStructured;
-const core_1 = require("@ton/core");
-const env_1 = require("./env");
-async function disasmStructured(code) {
-    await (0, env_1.wasmLoaded)();
-    let boc;
-    if (code instanceof core_1.Cell) {
-        boc = code.toBoc({ idx: false }).toString("base64");
-    }
-    else {
-        boc = code;
-    }
-    const res = env_1.wasm.disasm_structured(boc);
-    const parsed = JSON.parse(res);
-    return parsed;
-}
+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;
+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; } });
+Object.defineProperty(exports, "expectCont", { enumerable: true, get: function () { return structured_1.expectCont; } });
+Object.defineProperty(exports, "expectContArg", { enumerable: true, get: function () { return structured_1.expectContArg; } });
+Object.defineProperty(exports, "expectData", { enumerable: true, get: function () { return structured_1.expectData; } });
+Object.defineProperty(exports, "expectDataCell", { enumerable: true, get: function () { return structured_1.expectDataCell; } });
+Object.defineProperty(exports, "expectDataSlice", { enumerable: true, get: function () { return structured_1.expectDataSlice; } });
+Object.defineProperty(exports, "expectIntArg", { enumerable: true, get: function () { return structured_1.expectIntArg; } });
+Object.defineProperty(exports, "expectJumpTable", { enumerable: true, get: function () { return structured_1.expectJumpTable; } });
+Object.defineProperty(exports, "expectLibrary", { enumerable: true, get: function () { return structured_1.expectLibrary; } });
+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; } });
+var fift_1 = require("./disasm/fift");
+Object.defineProperty(exports, "disasmToFift", { enumerable: true, get: function () { return fift_1.disasmToFift; } });
+var slice_1 = require("./util/slice");
+Object.defineProperty(exports, "makeSlice", { enumerable: true, get: function () { return slice_1.makeSlice; } });

package/dist/util/slice.d.ts

@@ -0,0 +1,2 @@
+import { Cell, Slice } from "@ton/core";
+export declare function makeSlice(cell: Cell, offsetBits: number, offsetRefs: number, bits: number, refs: number): Slice;

package/dist/util/slice.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSlice = makeSlice;
+const core_1 = require("@ton/core");
+function makeSlice(cell, offsetBits, offsetRefs, bits, refs) {
+    const d = cell.asSlice().skip(offsetBits).loadBits(bits);
+    const b = (0, core_1.beginCell)().storeBits(d);
+    for (let i = offsetRefs; i < offsetRefs + refs; i++) {
+        b.storeRef(cell.refs[i]);
+    }
+    return b.asSlice();
+}

package/package.json

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