@fluffylabs/anan-as 1.2.0-ef04361 → 1.3.0-1ebcf8f

package/dist/build/js/assembly/instructions.js

@@ -3,7 +3,7 @@ export class Instruction {
     constructor() {
         this.name = "";
         this.kind = Arguments.Zero;
-        this.gas = i64(0);
+        this.gas = u32(0);
         this.isTerminating = false;
     }
 }
@@ -11,13 +11,13 @@ function instruction(name, kind, gas, isTerminating = false) {
     const i = new Instruction();
     i.name = name;
     i.kind = kind;
-    i.gas = i64(gas);
+    i.gas = u32(gas);
     i.isTerminating = isTerminating;
     return i;
 }
 export const MISSING_INSTRUCTION = instruction("INVALID", Arguments.Zero, 1, false);
 export const SBRK = instruction("SBRK", Arguments.TwoReg, 1);
-export const INSTRUCTIONS = [
+export const INSTRUCTIONS = StaticArray.fromArray([
     /* 000 */ instruction("TRAP", Arguments.Zero, 1, true),
     /* 001 */ instruction("FALLTHROUGH", Arguments.Zero, 1, true),
     MISSING_INSTRUCTION,
@@ -249,4 +249,4 @@ export const INSTRUCTIONS = [
     /* 228 */ instruction("MAX_U", Arguments.ThreeReg, 1),
     /* 229 */ instruction("MIN", Arguments.ThreeReg, 1),
     /* 230 */ instruction("MIN_U", Arguments.ThreeReg, 1),
-];
+]);

package/dist/build/js/assembly/interpreter.d.ts

@@ -19,7 +19,6 @@ export declare class Interpreter {
     status: Status;
     exitCode: u32;
     nextPc: u32;
-    useSbrkGas: boolean;
     private djumpRes;
     private argsRes;
     private outcomeRes;

package/dist/build/js/assembly/interpreter.js

@@ -1,11 +1,10 @@
 import { Args } from "./arguments";
 import { gasCounter } from "./gas";
-import { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from "./instructions";
+import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
 import { Outcome, OutcomeData, Result } from "./instructions/outcome";
-import { reg } from "./instructions/utils";
 import { RUN } from "./instructions-exe";
 import { MemoryBuilder } from "./memory";
-import { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from "./memory-page";
+import { RESERVED_MEMORY } from "./memory-page";
 import { portable } from "./portable";
 import { decodeArguments } from "./program";
 export var Status;
@@ -51,7 +50,6 @@ export class Interpreter {
         this.status = Status.OK;
         this.exitCode = 0;
         this.nextPc = 0;
-        this.useSbrkGas = false;
     }
     nextSteps(nSteps = 1) {
         // resuming after host call
@@ -72,9 +70,11 @@ export class Interpreter {
             this.nextPc = -1;
             return true;
         }
-        const program = this.program;
-        const code = program.code;
-        const mask = program.mask;
+        const code = this.program.code;
+        const mask = this.program.mask;
+        const gasCosts = this.program.gasCosts.codeAndGas;
+        const basicBlocks = this.program.basicBlocks;
+        const jumpTable = this.program.jumpTable;
         const argsRes = this.argsRes;
         const outcomeRes = this.outcomeRes;
         for (let i = 0; i < nSteps; i++) {
@@ -94,10 +94,12 @@ export class Interpreter {
                 }
                 return false;
             }
-            const instruction = code[pc];
-            const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;
-            // check gas (might be done for each block instead).
-            if (this.gas.sub(iData.gas)) {
+            // check gas via pre-computed cost table (per-instruction or per-block)
+            const codeAndGas = portable.staticArrayAt(gasCosts, pc);
+            const instruction = codeAndGas & 0xff;
+            const gasCost = codeAndGas >> 8;
+            const iData = instruction < INSTRUCTIONS.length ? unchecked(INSTRUCTIONS[instruction]) : MISSING_INSTRUCTION;
+            if (gasCost > 0 && this.gas.sub(gasCost)) {
                 this.status = Status.OOG;
                 return false;
             }
@@ -108,21 +110,25 @@ export class Interpreter {
             // get args and invoke instruction
             const skipBytes = mask.skipBytesToNextInstruction(pc);
             const args = decodeArguments(argsRes, iData.kind, code, pc + 1, skipBytes);
-            // additional gas cost of sbrk
-            if (iData === SBRK && this.useSbrkGas) {
-                const alloc = u64(u32(this.registers[reg(u64(args.a))]));
-                const gas = portable.u64_mul(portable.u64_sub(portable.u64_add(alloc, u64(PAGE_SIZE)), u64(1)) >> u64(PAGE_SIZE_SHIFT), u64(16));
-                if (this.gas.sub(gas)) {
-                    this.status = Status.OOG;
-                    return false;
-                }
-            }
-            const exe = RUN[instruction];
+            const exe = unchecked(RUN[instruction]);
             const outcome = exe(outcomeRes, args, this.registers, this.memory);
-            // TODO [ToDr] Spaghetti
+            // Fast path: Ok is the most common outcome (~70%+ of instructions)
+            if (outcome.outcome === Outcome.Ok) {
+                this.pc += 1 + skipBytes;
+                continue;
+            }
             switch (outcome.outcome) {
+                case Outcome.StaticJump: {
+                    const branchResult = branch(this.branchRes, basicBlocks, pc, outcome.staticJump);
+                    if (!branchResult.isOkay) {
+                        this.status = Status.PANIC;
+                        return false;
+                    }
+                    this.pc = branchResult.newPc;
+                    continue;
+                }
                 case Outcome.DynamicJump: {
-                    const res = dJump(this.djumpRes, program.jumpTable, outcome.dJump);
+                    const res = dJump(this.djumpRes, jumpTable, outcome.dJump);
                     if (res.status === DjumpStatus.HALT) {
                         this.status = Status.HALT;
                         return false;
@@ -131,16 +137,7 @@ export class Interpreter {
                         this.status = Status.PANIC;
                         return false;
                     }
-                    const branchResult = branch(this.branchRes, program.basicBlocks, res.newPc, 0);
-                    if (!branchResult.isOkay) {
-                        this.status = Status.PANIC;
-                        return false;
-                    }
-                    this.pc = branchResult.newPc;
-                    continue;
-                }
-                case Outcome.StaticJump: {
-                    const branchResult = branch(this.branchRes, program.basicBlocks, pc, outcome.staticJump);
+                    const branchResult = branch(this.branchRes, basicBlocks, res.newPc, 0);
                     if (!branchResult.isOkay) {
                         this.status = Status.PANIC;
                         return false;
@@ -179,11 +176,6 @@ export class Interpreter {
                     }
                     throw new Error("Unknown result");
                 }
-                case Outcome.Ok: {
-                    // by default move to next instruction.
-                    this.pc += 1 + skipBytes;
-                    continue;
-                }
             }
         }
         return true;

package/dist/build/js/assembly/math.d.ts

@@ -1,8 +1,6 @@
-/**
- * Integer minimum of two i32 values.
- */
-export declare function minI32(a: i32, b: i32): i32;
-/**
- * Unsigned integer minimum of two u32 values.
- */
-export declare function minU32(a: u32, b: u32): u32;
+export declare class IntMath {
+    /** Integer minimum of two i32 values. */
+    static minI32(a: i32, b: i32): i32;
+    /** Unsigned integer minimum of two u32 values. */
+    static minU32(a: u32, b: u32): u32;
+}

package/dist/build/js/assembly/math.js

@@ -1,14 +1,22 @@
-/**
- * Integer minimum of two i32 values.
- */
-// @inline
-export function minI32(a, b) {
-    return a < b ? a : b;
-}
-/**
- * Unsigned integer minimum of two u32 values.
- */
-// @inline
-export function minU32(a, b) {
-    return a < b ? a : b;
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+export class IntMath {
+    /** Integer minimum of two i32 values. */
+    static minI32(a, b) {
+        return a < b ? a : b;
+    }
+    /** Unsigned integer minimum of two u32 values. */
+    static minU32(a, b) {
+        return a < b ? a : b;
+    }
 }
+__decorate([
+    inline
+], IntMath, "minI32", null);
+__decorate([
+    inline
+], IntMath, "minU32", null);

package/dist/build/js/assembly/memory-page.d.ts

@@ -9,8 +9,6 @@ export declare const SEGMENT_SIZE_SHIFT: u32;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */
 export declare const RESERVED_MEMORY: u32;
 export declare const RESERVED_PAGES: u32;
-/** Amount of memory to allocate eagerly */
-export declare const ALLOCATE_EAGERLY: u32;
 export declare enum Access {
     None = 0,
     Read = 1,
@@ -24,8 +22,8 @@ export declare class Page {
 }
 export declare class RawPage {
     readonly id: ArenaId;
-    page: Uint8Array | null;
-    constructor(id: ArenaId, page: Uint8Array | null);
+    page: Uint8Array;
+    constructor(id: ArenaId, page: Uint8Array);
     get data(): Uint8Array;
 }
 export declare class Arena {

package/dist/build/js/assembly/memory-page.js

@@ -1,3 +1,9 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { portable } from "./portable";
 /** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */
 export const PAGE_SIZE = 2 ** 12; // 4_096
@@ -8,8 +14,6 @@ export const SEGMENT_SIZE_SHIFT = 16;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */
 export const RESERVED_MEMORY = 2 ** 16;
 export const RESERVED_PAGES = RESERVED_MEMORY / PAGE_SIZE; // 16
-/** Amount of memory to allocate eagerly */
-export const ALLOCATE_EAGERLY = 2 ** 21; // 2MB
 export var Access;
 (function (Access) {
     Access[Access["None"] = 0] = "None";
@@ -25,18 +29,21 @@ export class Page {
         return this.access === Access.Write || this.access === access;
     }
 }
+__decorate([
+    inline
+], Page.prototype, "can", null);
 export class RawPage {
     constructor(id, page) {
         this.id = id;
         this.page = page;
     }
     get data() {
-        if (this.page === null) {
-            this.page = new Uint8Array(PAGE_SIZE).fill(0);
-        }
         return this.page;
     }
 }
+__decorate([
+    inline
+], RawPage.prototype, "data", null);
 export class Arena {
     constructor(pageCount) {
         this.arenaBytes = PAGE_SIZE * pageCount;
@@ -57,8 +64,7 @@ export class Arena {
         if (allocatedMemory === this.arenaBytes) {
             console.log("Warning: Run out of pages! Allocating.");
         }
-        // actually allocate for some time, but later do it lazily
-        const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;
+        const data = new Uint8Array(PAGE_SIZE);
         this.extraPageIndex += 1;
         return new RawPage(this.extraPageIndex, data);
     }

package/dist/build/js/assembly/memory.d.ts

@@ -27,6 +27,7 @@ export declare class Memory {
     private pageResult;
     private chunksResult;
     private maxHeapPointer;
+    private cache;
     constructor(arena: Arena, pages?: Map<PageIndex, Page>, sbrkAddress?: u32, maxHeapPointer?: u32);
     pageDump(index: PageIndex): Uint8Array | null;
     /**

package/dist/build/js/assembly/memory.js

@@ -1,5 +1,11 @@
-import { u8SignExtend, u16SignExtend, u32SignExtend } from "./instructions/utils";
-import { minU32 } from "./math";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Inst } from "./instructions/utils";
+import { IntMath } from "./math";
 import { Access, Arena, PAGE_SIZE, PAGE_SIZE_SHIFT, Page, RawPage, RESERVED_MEMORY, RESERVED_PAGES, } from "./memory-page";
 import { portable } from "./portable";
 // @unmanaged
@@ -14,7 +20,7 @@ export class MaybePageFault {
     }
 }
 const EMPTY_UINT8ARRAY = new Uint8Array(0);
-const EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));
+const EMPTY_PAGE = new Page(Access.None, new RawPage(-1, EMPTY_UINT8ARRAY));
 class Chunks {
     constructor() {
         this.firstPageData = EMPTY_UINT8ARRAY;
@@ -31,6 +37,50 @@ class PageResult {
 }
 const MEMORY_SIZE = 4294967296;
 const MAX_MEMORY_ADDRESS = 4294967295;
+// Direct-mapped page cache for fast lookups.
+// Cache size must be a power of 2. 256 entries covers most working sets.
+const PAGE_CACHE_SHIFT = 8;
+const PAGE_CACHE_SIZE = 1 << PAGE_CACHE_SHIFT; // 256
+const PAGE_CACHE_MASK = PAGE_CACHE_SIZE - 1;
+class PageCache {
+    constructor() {
+        // Parallel arrays for cache: tags store the page index, entries store the page.
+        // A tag of 0xFFFFFFFF means empty (no valid page).
+        this.tags = new StaticArray(PAGE_CACHE_SIZE);
+        this.entries = new StaticArray(PAGE_CACHE_SIZE);
+        const empty = EMPTY_PAGE;
+        for (let i = 0; i < PAGE_CACHE_SIZE; i++) {
+            this.tags[i] = 0xffffffff;
+            this.entries[i] = empty;
+        }
+    }
+    lookup(pageIdx) {
+        const slot = pageIdx & PAGE_CACHE_MASK;
+        if (unchecked(this.tags[slot]) === pageIdx) {
+            return unchecked(this.entries[slot]);
+        }
+        return null;
+    }
+    insert(pageIdx, page) {
+        const slot = pageIdx & PAGE_CACHE_MASK;
+        // biome-ignore lint/suspicious/noAssignInExpressions: intentional AS pattern
+        unchecked((this.tags[slot] = pageIdx));
+        // biome-ignore lint/suspicious/noAssignInExpressions: intentional AS pattern
+        unchecked((this.entries[slot] = page));
+    }
+    clear() {
+        for (let i = 0; i < PAGE_CACHE_SIZE; i++) {
+            this.tags[i] = 0xffffffff;
+            this.entries[i] = EMPTY_PAGE;
+        }
+    }
+}
+__decorate([
+    inline
+], PageCache.prototype, "lookup", null);
+__decorate([
+    inline
+], PageCache.prototype, "insert", null);
 export class MemoryBuilder {
     constructor(preAllocatePages = 0) {
         this.pages = new Map();
@@ -83,18 +133,34 @@ export class Memory {
         this.sbrkAddress = sbrkAddress;
         this.pageResult = new PageResult();
         this.chunksResult = new Chunks();
+        this.cache = new PageCache();
         const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);
         if (sbrkPage < RESERVED_PAGES) {
             throw new Error("sbrk within reserved memory is not allowed!");
         }
         this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;
         this.maxHeapPointer = u64(maxHeapPointer);
+        // Pre-populate cache with all existing pages
+        // @ts-ignore: AS Map iterator has array-like behavior
+        const keys = pages.keys();
+        // @ts-ignore: AS Map iterator has array-like behavior
+        for (let i = 0; i < keys.length; i++) {
+            // @ts-ignore: AS Map iterator has array-like behavior
+            const key = keys[i];
+            this.cache.insert(key, pages.get(key));
+        }
     }
     pageDump(index) {
+        const cached = this.cache.lookup(index);
+        if (cached !== null) {
+            return cached.raw.data;
+        }
         if (!this.pages.has(index)) {
             return null;
         }
-        return this.pages.get(index).raw.data;
+        const page = this.pages.get(index);
+        this.cache.insert(index, page);
+        return page.raw.data;
     }
     /**
      * Returns the WASM linear memory pointer (byte offset) for the backing buffer of the page at `pageIndex`.
@@ -119,10 +185,14 @@ export class Memory {
      * ```
      */
     getPagePointer(pageIndex) {
-        if (!this.pages.has(pageIndex)) {
-            return 0;
+        let page = this.cache.lookup(pageIndex);
+        if (page === null) {
+            if (!this.pages.has(pageIndex)) {
+                return 0;
+            }
+            page = this.pages.get(pageIndex);
+            this.cache.insert(pageIndex, page);
         }
-        const page = this.pages.get(pageIndex);
         if (!page.can(Access.Read)) {
             return 0;
         }
@@ -137,6 +207,7 @@ export class Memory {
             this.arena.release(pages[i].raw);
         }
         this.pages.clear();
+        this.cache.clear();
     }
     sbrk(faultRes, amount) {
         const freeMemoryStart = u64(this.sbrkAddress);
@@ -152,13 +223,17 @@ export class Memory {
         this.sbrkAddress = u32(newSbrk);
         const pageIdx = i32(portable.u64_sub(newSbrk, u64(1)) >> u64(PAGE_SIZE_SHIFT));
         if (pageIdx === this.lastAllocatedPage) {
+            faultRes.isFault = false;
             return freeMemoryStart;
         }
         for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {
-            const page = this.arena.acquire();
-            this.pages.set(i, new Page(Access.Write, page));
+            const rawPage = this.arena.acquire();
+            const page = new Page(Access.Write, rawPage);
+            this.pages.set(i, page);
+            this.cache.insert(i, page);
         }
         this.lastAllocatedPage = pageIdx;
+        faultRes.isFault = false;
         return freeMemoryStart;
     }
     getU8(faultRes, address) {
@@ -174,13 +249,13 @@ export class Memory {
         return portable.bswap_u64(this.getBytesReversed(faultRes, Access.Read, address, 8));
     }
     getI8(faultRes, address) {
-        return u8SignExtend(u8(this.getU8(faultRes, address)));
+        return Inst.u8SignExtend(u8(this.getU8(faultRes, address)));
     }
     getI16(faultRes, address) {
-        return u16SignExtend(u16(this.getU16(faultRes, address)));
+        return Inst.u16SignExtend(u16(this.getU16(faultRes, address)));
     }
     getI32(faultRes, address) {
-        return u32SignExtend(u32(this.getU32(faultRes, address)));
+        return Inst.u32SignExtend(u32(this.getU32(faultRes, address)));
     }
     setU8(faultRes, address, value) {
         this.setBytes(faultRes, address, value, 1);
@@ -272,17 +347,34 @@ export class Memory {
     }
     getPage(faultRes, pageData, access, address) {
         const pageIdx = u32(address >> PAGE_SIZE_SHIFT);
-        const relAddress = address % PAGE_SIZE;
-        const pageStart = pageIdx << PAGE_SIZE_SHIFT;
+        const relAddress = address & (PAGE_SIZE - 1);
+        // Fast path: check cache first
+        const cached = this.cache.lookup(pageIdx);
+        if (cached !== null) {
+            if (!cached.can(access)) {
+                fault(faultRes, pageIdx << PAGE_SIZE_SHIFT);
+                faultRes.isAccess = true;
+                pageData.page = EMPTY_PAGE;
+                pageData.relativeAddress = relAddress;
+                return;
+            }
+            faultRes.isFault = false;
+            pageData.page = cached;
+            pageData.relativeAddress = relAddress;
+            return;
+        }
+        // Slow path: check Map
         if (!this.pages.has(pageIdx)) {
-            fault(faultRes, pageStart);
+            fault(faultRes, pageIdx << PAGE_SIZE_SHIFT);
             pageData.page = EMPTY_PAGE;
             pageData.relativeAddress = relAddress;
             return;
         }
         const page = this.pages.get(pageIdx);
+        // Insert into cache for next time
+        this.cache.insert(pageIdx, page);
         if (!page.can(access)) {
-            fault(faultRes, pageStart);
+            fault(faultRes, pageIdx << PAGE_SIZE_SHIFT);
             faultRes.isAccess = true;
             pageData.page = EMPTY_PAGE;
             pageData.relativeAddress = relAddress;
@@ -323,12 +415,16 @@ export class Memory {
         }
         const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;
         const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;
-        if (!this.pages.has(secondPageIdx)) {
-            fault(faultRes, secondPageStart);
-            return;
+        // Try cache first for second page
+        let secondPage = this.cache.lookup(secondPageIdx);
+        if (secondPage === null) {
+            if (!this.pages.has(secondPageIdx)) {
+                fault(faultRes, secondPageStart);
+                return;
+            }
+            secondPage = this.pages.get(secondPageIdx);
+            this.cache.insert(secondPageIdx, secondPage);
         }
-        // fetch the second page and check access
-        const secondPage = this.pages.get(secondPageIdx);
         if (!secondPage.can(access)) {
             fault(faultRes, secondPageStart);
             faultRes.isAccess = true;
@@ -349,7 +445,7 @@ export class Memory {
         }
         let bytesLeft = u64(value);
         // write to first page
-        const firstPageEnd = minU32(PAGE_SIZE, r.firstPageOffset + bytes);
+        const firstPageEnd = IntMath.minU32(PAGE_SIZE, r.firstPageOffset + bytes);
         for (let i = r.firstPageOffset; i < firstPageEnd; i++) {
             r.firstPageData[i] = u8(bytesLeft);
             bytesLeft >>= u64(8);
@@ -367,7 +463,7 @@ export class Memory {
         }
         // result (bytes in reverse order)
         let r = u64(0);
-        const firstPageEnd = minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
+        const firstPageEnd = IntMath.minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
         // read from first page
         for (let i = this.chunksResult.firstPageOffset; i < firstPageEnd; i++) {
             r = (r << u64(8)) | u64(this.chunksResult.firstPageData[i]);

package/dist/build/js/assembly/portable.js

@@ -24,6 +24,7 @@ export class portable {
             arr.fill(0);
             return arr;
         };
+        g.StaticArray.fromArray = (x) => x;
         g.ASC_TARGET = 0;
         g.i8 = (value) => {
             const n = typeof value === "bigint" ? Number(value) : value;

package/dist/build/js/assembly/program-build.js

@@ -1,7 +1,7 @@
 import { Arguments, higNibble, lowNibble, REQUIRED_BYTES } from "./arguments";
 import { encodeVarU32 } from "./codec";
 import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
-import { minI32 } from "./math";
+import { IntMath } from "./math";
 /** Turn given bytecode into a valid program. Add JumpTable and Mask. */
 export function wrapAsProgram(bytecode) {
     const jumpTableLength = 0;
@@ -57,9 +57,9 @@ function skipBytes(kind, data) {
         case Arguments.TwoReg:
             return 1;
         case Arguments.TwoRegOneImm:
-            return 1 + minI32(4, data.length);
+            return 1 + IntMath.minI32(4, data.length);
         case Arguments.TwoRegOneOff:
-            return 1 + minI32(4, data.length);
+            return 1 + IntMath.minI32(4, data.length);
         case Arguments.TwoRegTwoImm: {
             const low = lowNibble(data[1]);
             const split = low + 1;
@@ -100,5 +100,5 @@ function immBytes(dataLength, required) {
     if (dataLength < required) {
         return 0;
     }
-    return minI32(4, dataLength - required);
+    return IntMath.minI32(4, dataLength - required);
 }

package/dist/build/js/assembly/program.d.ts

@@ -1,6 +1,7 @@
 import { Args, Arguments } from "./arguments";
 import { Registers } from "./registers";
 export type ProgramCounter = u32;
+export type Code = StaticArray<u8>;
 export declare class CodeAndMetadata {
     readonly code: Uint8Array;
     readonly metadata: Uint8Array;
@@ -10,10 +11,10 @@ export declare class CodeAndMetadata {
 export declare function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata;
 /** Convert `u8` to `Uint8Array` */
 export declare function liftBytes(data: u8[]): Uint8Array;
-/**  Convert `Uint8Array` to `u8` */
-export declare function lowerBytes(data: Uint8Array): u8[];
+/**  Convert `Uint8Array` to `Code` (StaticArray<u8>) */
+export declare function lowerBytes(data: Uint8Array): Code;
 /** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */
-export declare function deblob(program: Uint8Array): Program;
+export declare function deblob(program: Uint8Array, useBlockGas: boolean): Program;
 /**
  * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5
  */
@@ -39,6 +40,11 @@ export declare class Mask {
     skipBytesToNextInstruction(i: u32): u32;
     toString(): string;
 }
+export declare class GasCosts {
+    readonly codeAndGas: StaticArray<u32>;
+    constructor(code: Code, mask: Mask, blocks: BasicBlocks, useBlockGasCost: boolean);
+    toString(): string;
+}
 export declare enum BasicBlock {
     NONE = 0,
     START = 2,
@@ -49,7 +55,7 @@ export declare enum BasicBlock {
  */
 export declare class BasicBlocks {
     readonly isStartOrEnd: StaticArray<BasicBlock>;
-    constructor(code: u8[], mask: Mask);
+    constructor(code: Code, mask: Mask);
     isStart(newPc: u32): boolean;
     toString(): string;
 }
@@ -59,14 +65,15 @@ export declare class JumpTable {
     toString(): string;
 }
 export declare class Program {
-    readonly code: u8[];
+    readonly code: Code;
     readonly mask: Mask;
     readonly jumpTable: JumpTable;
     readonly basicBlocks: BasicBlocks;
-    constructor(code: u8[], mask: Mask, jumpTable: JumpTable, basicBlocks: BasicBlocks);
+    readonly gasCosts: GasCosts;
+    constructor(code: Code, mask: Mask, jumpTable: JumpTable, basicBlocks: BasicBlocks, gasCosts: GasCosts);
     toString(): string;
 }
-export declare function decodeArguments(args: Args, kind: Arguments, code: u8[], offset: i32, lim: u32): Args;
+export declare function decodeArguments(args: Args, kind: Arguments, code: Code, offset: i32, lim: u32): Args;
 declare class ResolvedArguments {
     a: i64;
     b: i64;
@@ -74,5 +81,5 @@ declare class ResolvedArguments {
     d: i64;
     decoded: Args;
 }
-export declare function resolveArguments(argsRes: Args, kind: Arguments, code: u8[], offset: u32, lim: u32, registers: Registers): ResolvedArguments | null;
+export declare function resolveArguments(argsRes: Args, kind: Arguments, code: Code, offset: u32, lim: u32, registers: Registers): ResolvedArguments | null;
 export {};