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

package/dist/build/js/assembly/instructions/outcome.d.ts

@@ -20,11 +20,11 @@ export declare class OutcomeData {
     dJump: u32;
     result: Result;
     exitCode: u32;
+    static status(r: OutcomeData, result: Result): OutcomeData;
+    static staticJump(r: OutcomeData, offset: i32): OutcomeData;
+    static dJump(r: OutcomeData, address: u32): OutcomeData;
+    static ok(r: OutcomeData): OutcomeData;
+    static panic(r: OutcomeData): OutcomeData;
+    static hostCall(r: OutcomeData, id: u32): OutcomeData;
+    static okOrFault(r: OutcomeData, pageFault: MaybePageFault): OutcomeData;
 }
-export declare function status(r: OutcomeData, result: Result): OutcomeData;
-export declare function staticJump(r: OutcomeData, offset: i32): OutcomeData;
-export declare function dJump(r: OutcomeData, address: u32): OutcomeData;
-export declare function ok(r: OutcomeData): OutcomeData;
-export declare function panic(r: OutcomeData): OutcomeData;
-export declare function hostCall(r: OutcomeData, id: u32): OutcomeData;
-export declare function okOrFault(r: OutcomeData, pageFault: MaybePageFault): OutcomeData;

package/dist/build/js/assembly/instructions/outcome.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;
+};
 export var Result;
 (function (Result) {
     Result[Result["PANIC"] = 0] = "PANIC";
@@ -12,7 +18,6 @@ export var Outcome;
     Outcome[Outcome["DynamicJump"] = 2] = "DynamicJump";
     Outcome[Outcome["Result"] = 3] = "Result";
 })(Outcome || (Outcome = {}));
-// @unmanaged
 export class OutcomeData {
     constructor() {
         this.outcome = Outcome.Ok;
@@ -21,43 +26,63 @@ export class OutcomeData {
         this.result = Result.PANIC;
         this.exitCode = 0;
     }
-}
-export function status(r, result) {
-    r.outcome = Outcome.Result;
-    r.result = result;
-    return r;
-}
-export function staticJump(r, offset) {
-    r.outcome = Outcome.StaticJump;
-    r.staticJump = offset;
-    return r;
-}
-export function dJump(r, address) {
-    r.outcome = Outcome.DynamicJump;
-    r.dJump = address;
-    return r;
-}
-export function ok(r) {
-    r.outcome = Outcome.Ok;
-    r.dJump = 0;
-    return r;
-}
-export function panic(r) {
-    return status(r, Result.PANIC);
-}
-export function hostCall(r, id) {
-    r.outcome = Outcome.Result;
-    r.result = Result.HOST;
-    r.exitCode = id;
-    return r;
-}
-export function okOrFault(r, pageFault) {
-    if (pageFault.isFault) {
+    static status(r, result) {
         r.outcome = Outcome.Result;
-        // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP
-        // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.
-        r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
-        r.exitCode = pageFault.fault;
+        r.result = result;
+        return r;
+    }
+    static staticJump(r, offset) {
+        r.outcome = Outcome.StaticJump;
+        r.staticJump = offset;
+        return r;
+    }
+    static dJump(r, address) {
+        r.outcome = Outcome.DynamicJump;
+        r.dJump = address;
+        return r;
+    }
+    static ok(r) {
+        // outcome is already pre-set to Ok by the interpreter loop
+        return r;
+    }
+    static panic(r) {
+        return OutcomeData.status(r, Result.PANIC);
+    }
+    static hostCall(r, id) {
+        r.outcome = Outcome.Result;
+        r.result = Result.HOST;
+        r.exitCode = id;
+        return r;
+    }
+    static okOrFault(r, pageFault) {
+        if (pageFault.isFault) {
+            r.outcome = Outcome.Result;
+            // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP
+            // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.
+            r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
+            r.exitCode = pageFault.fault;
+        }
+        return r;
     }
-    return r;
 }
+__decorate([
+    inline
+], OutcomeData, "status", null);
+__decorate([
+    inline
+], OutcomeData, "staticJump", null);
+__decorate([
+    inline
+], OutcomeData, "dJump", null);
+__decorate([
+    inline
+], OutcomeData, "ok", null);
+__decorate([
+    inline
+], OutcomeData, "panic", null);
+__decorate([
+    inline
+], OutcomeData, "hostCall", null);
+__decorate([
+    inline
+], OutcomeData, "okOrFault", null);

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

@@ -1,45 +1,45 @@
 import { portable } from "../portable";
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // ROT_R_64_IMM
 export const rot_r_64_imm = (r, args, regs) => {
-    regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));
-    return ok(r);
+    regs[Inst.reg(args.b)] = math.rot_r(regs[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+    return OutcomeData.ok(r);
 };
 // ROT_R_64_IMM_ALT
 export const rot_r_64_imm_alt = (r, args, regs) => {
-    regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = math.rot_r(Inst.u32SignExtend(args.c), regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_R_32_IMM
 export const rot_r_32_imm = (r, args, regs) => {
-    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.a)]), u32(args.c)));
+    return OutcomeData.ok(r);
 };
 // ROT_R_32_IMM_ALT
 export const rot_r_32_imm_alt = (r, args, regs) => {
-    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // ROT_L_64
 export const rot_l_64 = (r, args, regs) => {
-    regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.c)] = math.rot_l(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_L_32
 export const rot_l_32 = (r, args, regs) => {
-    regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_l_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // ROT_R_64
 export const rot_r_64 = (r, args, regs) => {
-    regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.c)] = math.rot_r(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_R_32
 export const rot_r_32 = (r, args, regs) => {
-    regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 export var math;
 (function (math) {

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

@@ -1,36 +1,36 @@
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // SET_LT_U_IMM
 export const set_lt_u_imm = (r, args, registers) => {
-    const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = registers[Inst.reg(args.a)] < u64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_S_IMM
 export const set_lt_s_imm = (r, args, registers) => {
-    const cond = i64(registers[reg(args.a)]) < i64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = i64(registers[Inst.reg(args.a)]) < i64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_GT_U_IMM
 export const set_gt_u_imm = (r, args, registers) => {
-    const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = registers[Inst.reg(args.a)] > u64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_GT_S_IMM
 export const set_gt_s_imm = (r, args, registers) => {
-    const cond = i64(registers[reg(args.a)]) > i64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = i64(registers[Inst.reg(args.a)]) > i64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_U
 export const set_lt_u = (r, args, registers) => {
-    registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? u64(1) : u64(0);
-    return ok(r);
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] < registers[Inst.reg(args.a)] ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_S
 export const set_lt_s = (r, args, registers) => {
-    registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? u64(1) : u64(0);
-    return ok(r);
+    registers[Inst.reg(args.c)] = i64(registers[Inst.reg(args.b)]) < i64(registers[Inst.reg(args.a)]) ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };

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

@@ -1,121 +1,121 @@
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 const MAX_SHIFT_64 = 64;
 const MAX_SHIFT_32 = 32;
 // SHLO_L_IMM_32
 export const shlo_l_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32(registers[reg(args.a)]);
-    registers[reg(args.b)] = u32SignExtend(value << shift);
-    return ok(r);
+    const value = u32(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(value << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_32
 export const shlo_r_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32(registers[reg(args.a)]);
-    registers[reg(args.b)] = u32SignExtend(value >>> shift);
-    return ok(r);
+    const value = u32(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(value >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_32
 export const shar_r_imm_32 = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_32);
-    const value = u32SignExtend(u32(registers[reg(args.a)]));
-    registers[reg(args.b)] = u64(i64(value) >> i64(shift));
-    return ok(r);
+    const value = Inst.u32SignExtend(u32(registers[Inst.reg(args.a)]));
+    registers[Inst.reg(args.b)] = u64(i64(value) >> i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM_ALT_32
 export const shlo_l_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    registers[reg(args.b)] = u32SignExtend(args.c << shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_ALT_32
 export const shlo_r_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    registers[reg(args.b)] = u32SignExtend(args.c >>> shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_ALT_32
 export const shar_r_imm_alt_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const imm = u32SignExtend(args.c);
-    registers[reg(args.b)] = u32SignExtend(u32(i64(imm) >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const imm = Inst.u32SignExtend(args.c);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(i64(imm) >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM
 export const shlo_l_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    registers[reg(args.b)] = u64(registers[reg(args.a)] << u64(shift));
-    return ok(r);
+    registers[Inst.reg(args.b)] = u64(registers[Inst.reg(args.a)] << u64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM
 export const shlo_r_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    registers[reg(args.b)] = registers[reg(args.a)] >> u64(shift);
-    return ok(r);
+    registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM
 export const shar_r_imm = (r, args, registers) => {
     const shift = u32(args.c % MAX_SHIFT_64);
-    const value = i64(registers[reg(args.a)]);
-    registers[reg(args.b)] = u64(value >> i64(shift));
-    return ok(r);
+    const value = i64(registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = u64(value >> i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_IMM_ALT
 export const shlo_l_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.b)] = u64(u32SignExtend(args.c) << i64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c) << i64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R_IMM_ALT
 export const shlo_r_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.b)] = u64(u32SignExtend(args.c)) >> u64(shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c)) >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_IMM_ALT
 export const shar_r_imm_alt = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    const value = u32SignExtend(args.c);
-    registers[reg(args.b)] = u32SignExtend(u32(value >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    const value = Inst.u32SignExtend(args.c);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(value >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L_32
 export const shlo_l_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const value = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(value << shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const value = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(value << shift);
+    return OutcomeData.ok(r);
 };
 // SHLO_R_32
 export const shlo_r_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const value = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(value >>> shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const value = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(value >>> shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R_32
 export const shar_r_32 = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-    const regValue = u32SignExtend(u32(registers[reg(args.b)]));
-    registers[reg(args.c)] = u32SignExtend(u32(i64(regValue) >> i64(shift)));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+    const regValue = Inst.u32SignExtend(u32(registers[Inst.reg(args.b)]));
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(i64(regValue) >> i64(shift)));
+    return OutcomeData.ok(r);
 };
 // SHLO_L
 export const shlo_l = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = u64(registers[reg(args.b)] << u64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = u64(registers[Inst.reg(args.b)] << u64(shift));
+    return OutcomeData.ok(r);
 };
 // SHLO_R
 export const shlo_r = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = registers[reg(args.b)] >> u64(shift);
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] >> u64(shift);
+    return OutcomeData.ok(r);
 };
 // SHAR_R
 export const shar_r = (r, args, registers) => {
-    const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-    registers[reg(args.c)] = u64(i64(registers[reg(args.b)]) >> i64(shift));
-    return ok(r);
+    const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+    registers[Inst.reg(args.c)] = u64(i64(registers[Inst.reg(args.b)]) >> i64(shift));
+    return OutcomeData.ok(r);
 };

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

@@ -1,101 +1,101 @@
 import { MaybePageFault } from "../memory";
 import { portable } from "../portable";
-import { okOrFault } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 const faultRes = new MaybePageFault();
 // Helper function to compute effective address from base register and signed 32-bit offset
 function effectiveAddress(registers, baseReg, offset) {
-    return u32(portable.u64_add(registers[reg(u64(baseReg))], u32SignExtend(offset)));
+    return u32(portable.u64_add(registers[Inst.reg(u64(baseReg))], Inst.u32SignExtend(offset)));
 }
 // STORE_IMM_U8
 export const store_imm_u8 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU8(faultRes, address, (args.b & 0xff));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U16
 export const store_imm_u16 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU16(faultRes, address, (args.b & 65535));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U32
 export const store_imm_u32 = (r, args, _registers, memory) => {
     const address = args.a;
     memory.setU32(faultRes, address, args.b);
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_U64
 export const store_imm_u64 = (r, args, _registers, memory) => {
     const address = args.a;
-    memory.setU64(faultRes, address, u32SignExtend(args.b));
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, Inst.u32SignExtend(args.b));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U8
 export const store_u8 = (r, args, registers, memory) => {
-    memory.setU8(faultRes, args.b, (registers[reg(args.a)] & u64(0xff)));
-    return okOrFault(r, faultRes);
+    memory.setU8(faultRes, args.b, (registers[Inst.reg(args.a)] & u64(0xff)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U16
 export const store_u16 = (r, args, registers, memory) => {
-    memory.setU16(faultRes, args.b, (registers[reg(args.a)] & u64(65535)));
-    return okOrFault(r, faultRes);
+    memory.setU16(faultRes, args.b, (registers[Inst.reg(args.a)] & u64(65535)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U32
 export const store_u32 = (r, args, registers, memory) => {
-    memory.setU32(faultRes, args.b, u32(registers[reg(args.a)]));
-    return okOrFault(r, faultRes);
+    memory.setU32(faultRes, args.b, u32(registers[Inst.reg(args.a)]));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_U64
 export const store_u64 = (r, args, registers, memory) => {
-    memory.setU64(faultRes, args.b, registers[reg(args.a)]);
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, args.b, registers[Inst.reg(args.a)]);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U8
 export const store_imm_ind_u8 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU8(faultRes, address, (args.c & 0xff));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U16
 export const store_imm_ind_u16 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU16(faultRes, address, (args.c & 65535));
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U32
 export const store_imm_ind_u32 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
     memory.setU32(faultRes, address, args.c);
-    return okOrFault(r, faultRes);
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IMM_IND_U64
 export const store_imm_ind_u64 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.b);
-    memory.setU64(faultRes, address, u32SignExtend(args.c));
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, Inst.u32SignExtend(args.c));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U8
 export const store_ind_u8 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU8(faultRes, address, (registers[reg(args.b)] & u64(0xff)));
-    return okOrFault(r, faultRes);
+    memory.setU8(faultRes, address, (registers[Inst.reg(args.b)] & u64(0xff)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U16
 export const store_ind_u16 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU16(faultRes, address, (registers[reg(args.b)] & u64(65535)));
-    return okOrFault(r, faultRes);
+    memory.setU16(faultRes, address, (registers[Inst.reg(args.b)] & u64(65535)));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U32
 export const store_ind_u32 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU32(faultRes, address, u32(registers[reg(args.b)]));
-    return okOrFault(r, faultRes);
+    memory.setU32(faultRes, address, u32(registers[Inst.reg(args.b)]));
+    return OutcomeData.okOrFault(r, faultRes);
 };
 // STORE_IND_U64
 export const store_ind_u64 = (r, args, registers, memory) => {
     const address = effectiveAddress(registers, args.a, args.c);
-    memory.setU64(faultRes, address, registers[reg(args.b)]);
-    return okOrFault(r, faultRes);
+    memory.setU64(faultRes, address, registers[Inst.reg(args.b)]);
+    return OutcomeData.okOrFault(r, faultRes);
 };

package/dist/build/js/assembly/instructions/utils.d.ts

@@ -17,7 +17,9 @@ export declare function mulUpperUnsigned(a: u64, b: u64): u64;
  */
 export declare function mulUpperSigned(a: i64, b: i64): u64;
 export declare function mulUpperSignedUnsigned(a: i64, b: u64): u64;
-export declare function u8SignExtend(v: u8): i64;
-export declare function u16SignExtend(v: u16): i64;
-export declare function u32SignExtend(v: u32): i64;
-export declare function reg(v: u64): u32;
+export declare class Inst {
+    static u8SignExtend(v: u8): i64;
+    static u16SignExtend(v: u16): i64;
+    static u32SignExtend(v: u32): i64;
+    static reg(v: u64): u32;
+}

package/dist/build/js/assembly/instructions/utils.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";
 import { NO_OF_REGISTERS } from "../registers";
 /**
@@ -56,20 +62,30 @@ export function mulUpperSignedUnsigned(a, b) {
     }
     return mulUpperUnsigned(a, b);
 }
-// @inline
-export function u8SignExtend(v) {
-    // u64 wrap ensures unsigned representation in JS BigInt (no-op in AS)
-    return u64(i64(i32(i16(i8(v)))));
-}
-// @inline
-export function u16SignExtend(v) {
-    return u64(i64(i32(i16(v))));
-}
-// @inline
-export function u32SignExtend(v) {
-    return u64(i64(i32(v)));
-}
-// @inline
-export function reg(v) {
-    return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
+export class Inst {
+    static u8SignExtend(v) {
+        // u64 wrap ensures unsigned representation in JS BigInt (no-op in AS)
+        return u64(i64(i32(i16(i8(v)))));
+    }
+    static u16SignExtend(v) {
+        return u64(i64(i32(i16(v))));
+    }
+    static u32SignExtend(v) {
+        return u64(i64(i32(v)));
+    }
+    static reg(v) {
+        return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
+    }
 }
+__decorate([
+    inline
+], Inst, "u8SignExtend", null);
+__decorate([
+    inline
+], Inst, "u16SignExtend", null);
+__decorate([
+    inline
+], Inst, "u32SignExtend", null);
+__decorate([
+    inline
+], Inst, "reg", null);

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

@@ -1,11 +1,10 @@
 import { Arguments } from "./arguments";
-import { Gas } from "./gas";
 export declare class Instruction {
     name: string;
     kind: Arguments;
-    gas: Gas;
+    gas: u32;
     isTerminating: boolean;
 }
 export declare const MISSING_INSTRUCTION: Instruction;
 export declare const SBRK: Instruction;
-export declare const INSTRUCTIONS: Instruction[];
+export declare const INSTRUCTIONS: StaticArray<Instruction>;