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

package/dist/build/js/assembly/api-utils.d.ts

@@ -1,5 +1,6 @@
 import { InitialChunk, InitialPage, VmOutput, VmPause } from "./api-types";
-import { BlockGasCost } from "./gas-costs";
+import { Gas } from "./gas";
+import { ProgramCounter } from "./program";
 import { StandardProgram } from "./spi";
 export declare enum InputKind {
     Generic = 0,
@@ -9,7 +10,11 @@ export declare enum HasMetadata {
     Yes = 0,
     No = 1
 }
-export declare function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[];
+declare class BlockGasCost {
+    pc: ProgramCounter;
+    gas: Gas;
+}
+export declare function getBlockGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[];
 export declare function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string;
 export declare function prepareProgram(kind: InputKind, hasMetadata: HasMetadata, program: u8[], 
 /** NOTE: ignored in case of SPI. */
@@ -21,15 +26,17 @@ initialMemory: InitialChunk[],
 /** NOTE: ONLY needed for SPI. */
 args: u8[], 
 /** Preallocate a bunch of memory pages for faster execution. */
-preallocateMemoryPages: u32): StandardProgram;
+preallocateMemoryPages: u32, 
+/** Compute gas per-block instead of per-instruction. */
+useBlockGas: boolean): StandardProgram;
 /** Execute PVM program and stop. */
-export declare function runProgram(program: StandardProgram, initialGas?: i64, programCounter?: u32, logs?: boolean, useSbrkGas?: boolean, dumpMemory?: boolean): VmOutput;
+export declare function runProgram(program: StandardProgram, initialGas?: i64, programCounter?: u32, logs?: boolean, dumpMemory?: boolean): VmOutput;
 /**
  * Allocate new PVM instance to execute given program.
  *
  * NOTE: the PVM MUST be de-allocated using `pvmDestroy`.
  */
-export declare function pvmStart(program: StandardProgram, useSbrkGas?: boolean): u32;
+export declare function pvmStart(program: StandardProgram): u32;
 /** Deallocate PVM resources. */
 export declare function pvmDestroy(pvmId: u32): VmOutput | null;
 /** Set register values of a paused PVM. */
@@ -68,4 +75,5 @@ export declare function pvmGetPagePointer(pvmId: u32, page: u32): usize;
 /** Write a chunk of memory to given PVM instance. */
 export declare function pvmWriteMemory(pvmId: u32, address: u32, data: Uint8Array): boolean;
 /** Resume execution of paused VM. */
-export declare function pvmResume(pvmId: u32, gas: i64, pc: u32, logs?: boolean): VmPause | null;
+export declare function pvmResume(pvmId: u32, gas: Gas, pc: u32, logs?: boolean): VmPause | null;
+export {};

package/dist/build/js/assembly/api-utils.js

@@ -1,8 +1,6 @@
 import { buildMemory, getAssembly, vmDestroy, vmExecute, vmInit, vmRunOnce } from "./api-internal";
 import { VmInput, VmPause, VmRunOptions } from "./api-types";
-import { computeGasCosts } from "./gas-costs";
 import { MaybePageFault, MemoryBuilder } from "./memory";
-import { portable } from "./portable";
 import { deblob, extractCodeAndMetadata, liftBytes } from "./program";
 import { NO_OF_REGISTERS, newRegisters } from "./registers";
 import { decodeSpi, StandardProgram } from "./spi";
@@ -16,13 +14,29 @@ export var HasMetadata;
     HasMetadata[HasMetadata["Yes"] = 0] = "Yes";
     HasMetadata[HasMetadata["No"] = 1] = "No";
 })(HasMetadata || (HasMetadata = {}));
-export function getGasCosts(input, kind, withMetadata) {
-    const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0);
-    // @ts-ignore: AS returns T[], JS returns iterator - asArray handles both
-    return portable.asArray(computeGasCosts(program.program).values());
+class BlockGasCost {
+    constructor() {
+        this.pc = 0;
+        this.gas = 0;
+    }
+}
+export function getBlockGasCosts(input, kind, withMetadata) {
+    const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0, true);
+    const blockCosts = [];
+    const costs = program.program.gasCosts.codeAndGas;
+    for (let n = 0; n < costs.length; n += 1) {
+        const gas = costs[n] >> 8;
+        if (gas !== 0) {
+            const x = new BlockGasCost();
+            x.pc = n;
+            x.gas = costs[n];
+            blockCosts.push(x);
+        }
+    }
+    return blockCosts;
 }
 export function disassemble(input, kind, withMetadata) {
-    const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0);
+    const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0, false);
     let output = "";
     if (withMetadata === HasMetadata.Yes) {
         output = "Metadata: \n";
@@ -43,7 +57,9 @@ initialMemory,
 /** NOTE: ONLY needed for SPI. */
 args, 
 /** Preallocate a bunch of memory pages for faster execution. */
-preallocateMemoryPages) {
+preallocateMemoryPages, 
+/** Compute gas per-block instead of per-instruction. */
+useBlockGas) {
     let code = liftBytes(program);
     let metadata = new Uint8Array(0);
     if (hasMetadata === HasMetadata.Yes) {
@@ -54,7 +70,7 @@ preallocateMemoryPages) {
         metadata = data.metadata;
     }
     if (kind === InputKind.Generic) {
-        const program = deblob(code);
+        const program = deblob(code, useBlockGas);
         const builder = new MemoryBuilder(preallocateMemoryPages);
         const memory = buildMemory(builder, initialPageMap, initialMemory);
         const registers = newRegisters();
@@ -74,13 +90,12 @@ preallocateMemoryPages) {
     throw new Error(`Unknown kind: ${kind}`);
 }
 /** Execute PVM program and stop. */
-export function runProgram(program, initialGas = 0, programCounter = 0, logs = false, useSbrkGas = false, dumpMemory = false) {
+export function runProgram(program, initialGas = 0, programCounter = 0, logs = false, dumpMemory = false) {
     const vmInput = new VmInput(program.program, program.memory, program.registers);
     vmInput.gas = i64(initialGas);
     vmInput.pc = programCounter;
     const vmOptions = new VmRunOptions();
     vmOptions.logs = logs;
-    vmOptions.useSbrkGas = useSbrkGas;
     vmOptions.dumpMemory = dumpMemory;
     return vmRunOnce(vmInput, vmOptions);
 }
@@ -93,10 +108,10 @@ const pvms = new Map();
  *
  * NOTE: the PVM MUST be de-allocated using `pvmDestroy`.
  */
-export function pvmStart(program, useSbrkGas = false) {
+export function pvmStart(program) {
     const vmInput = new VmInput(program.program, program.memory, program.registers);
     nextPvmId += 1;
-    pvms.set(nextPvmId, vmInit(vmInput, useSbrkGas));
+    pvms.set(nextPvmId, vmInit(vmInput));
     return nextPvmId;
 }
 /** Deallocate PVM resources. */

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

@@ -14,9 +14,9 @@ export declare enum Arguments {
     ThreeReg = 12
 }
 /** How many numbers in `Args` is relevant for given `Arguments`. */
-export declare const RELEVANT_ARGS: number[];
+export declare const RELEVANT_ARGS: StaticArray<i32>;
 /** How many bytes is required by given `Arguments`. */
-export declare const REQUIRED_BYTES: number[];
+export declare const REQUIRED_BYTES: StaticArray<i32>;
 export declare class Args {
     fill(a: u32, b?: u32, c?: u32, d?: u32): Args;
     /**
@@ -37,8 +37,8 @@ export declare class Args {
     c: u32;
     d: u32;
 }
-type ArgsDecoder = (args: Args, code: u8[], offset: u32, end: u32) => Args;
-export declare const DECODERS: ArgsDecoder[];
+type ArgsDecoder = (args: Args, code: StaticArray<u8>, offset: u32, end: u32) => Args;
+export declare const DECODERS: StaticArray<ArgsDecoder>;
 export declare function lowNibble(byte: u8): u8;
 export declare function higNibble(byte: u8): u8;
 export {};

package/dist/build/js/assembly/arguments.js

@@ -1,4 +1,4 @@
-import { minI32 } from "./math";
+import { IntMath } from "./math";
 import { portable } from "./portable";
 export var Arguments;
 (function (Arguments) {
@@ -17,9 +17,9 @@ export var Arguments;
     Arguments[Arguments["ThreeReg"] = 12] = "ThreeReg";
 })(Arguments || (Arguments = {}));
 /** How many numbers in `Args` is relevant for given `Arguments`. */
-export const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];
+export const RELEVANT_ARGS = StaticArray.fromArray([0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3]);
 /** How many bytes is required by given `Arguments`. */
-export const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];
+export const REQUIRED_BYTES = StaticArray.fromArray([0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2]);
 // @unmanaged
 export class Args {
     constructor() {
@@ -50,13 +50,13 @@ export class Args {
     }
 }
 function twoImm(args, code, offset, end) {
-    const low = lowNibble(portable.arrayAt(code, offset));
-    const split = minI32(4, low) + 1;
+    const low = lowNibble(portable.staticArrayAt(code, offset));
+    const split = IntMath.minI32(4, low) + 1;
     const first = decodeI32(code, offset + 1, offset + split);
     const second = decodeI32(code, offset + split, end);
     return args.fill(first, second, 0, 0);
 }
-export const DECODERS = [
+export const DECODERS = StaticArray.fromArray([
     // DECODERS[Arguments.Zero] =
     (args, _d, _o, _l) => {
         return args.fill(0, 0, 0, 0);
@@ -86,7 +86,7 @@ export const DECODERS = [
     (args, data, o, lim) => {
         const h = higNibble(data[o]);
         const l = lowNibble(data[o]);
-        const split = minI32(4, h) + 1;
+        const split = IntMath.minI32(4, h) + 1;
         const immA = decodeI32(data, o + 1, o + split);
         const immB = decodeI32(data, o + split, lim);
         return args.fill(l, immA, immB, 0);
@@ -95,7 +95,7 @@ export const DECODERS = [
     (args, data, o, lim) => {
         const h = higNibble(data[o]);
         const l = lowNibble(data[o]);
-        const split = minI32(4, h) + 1;
+        const split = IntMath.minI32(4, h) + 1;
         const immA = decodeI32(data, o + 1, o + split);
         const offs = decodeI32(data, o + split, lim);
         return args.fill(l, immA, offs, 0);
@@ -130,7 +130,7 @@ export const DECODERS = [
         const b = lowNibble(data[o + 1]);
         return args.fill(hig, low, b, 0);
     },
-];
+]);
 // @inline
 export function lowNibble(byte) {
     return byte & 0xf;
@@ -149,7 +149,7 @@ function decodeI32(input, start, end) {
     for (let i = 0; i < len; i++) {
         num |= u32(input[start + i]) << (i * 8);
     }
-    const msb = portable.arrayAt(input, start + len - 1) & 0x80;
+    const msb = portable.staticArrayAt(input, start + len - 1) & 0x80;
     if (len < 4 && msb > 0) {
         num |= 4294967295 << (len * 8);
     }

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

@@ -1,16 +1,11 @@
 /** Gas type. */
-export type Gas = i64;
-/** Create a new gas counter instance depending on the gas value. */
-export declare function gasCounter(gas: i64): GasCounter;
-/** An abstraction over gas counter.
- *
- * It can be optimized to use numbers instead of bigint in case of small gas.
- */
-export interface GasCounter {
-    /** Return remaining gas. */
-    get(): Gas;
-    /** Overwite remaining gas. Prefer sub method instead. */
+export type Gas = u64;
+/** Create a new gas counter instance. */
+export declare function gasCounter(gas: Gas): GasCounter;
+export declare class GasCounter {
+    private gas;
+    constructor(gas: Gas);
     set(g: Gas): void;
-    /** Returns true if there was an underflow. */
-    sub(g: Gas): boolean;
+    get(): Gas;
+    sub(g: u32): boolean;
 }

package/dist/build/js/assembly/gas.js

@@ -1,23 +1,33 @@
-/** Create a new gas counter instance depending on the gas value. */
+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;
+};
+/** Create a new gas counter instance. */
 export function gasCounter(gas) {
-    return new GasCounterU64(gas);
+    return new GasCounter(gas);
 }
-class GasCounterU64 {
+export class GasCounter {
     constructor(gas) {
         this.gas = gas;
     }
     set(g) {
-        this.gas = i64(g);
+        this.gas = g;
     }
     get() {
         return this.gas;
     }
     sub(g) {
-        this.gas = this.gas - i64(g);
-        if (this.gas < i64(0)) {
-            this.gas = i64(0);
+        const cost = u64(g);
+        if (cost > this.gas) {
+            this.gas = u64(0);
             return true;
         }
+        this.gas = this.gas - cost;
         return false;
     }
 }
+__decorate([
+    inline
+], GasCounter.prototype, "sub", null);

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

@@ -1,53 +1,53 @@
 import { portable } from "../portable";
-import { ok } from "./outcome";
-import { reg, u8SignExtend, u16SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // COUNT_SET_BITS_64
 export const count_set_bits_64 = (r, args, regs) => {
-    regs[reg(args.b)] = portable.popcnt_u64(regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = portable.popcnt_u64(regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // COUNT_SET_BITS_32
 export const count_set_bits_32 = (r, args, regs) => {
-    regs[reg(args.b)] = u64(portable.popcnt_u32(u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.b)] = u64(portable.popcnt_u32(u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // LEADING_ZERO_BITS_64
 export const leading_zero_bits_64 = (r, args, regs) => {
-    regs[reg(args.b)] = portable.clz_u64(regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = portable.clz_u64(regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // LEADING_ZERO_BITS_32
 export const leading_zero_bits_32 = (r, args, regs) => {
-    regs[reg(args.b)] = u64(portable.clz_u32(u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.b)] = u64(portable.clz_u32(u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // TRAILING_ZERO_BITS_64
 export const trailing_zero_bits_64 = (r, args, regs) => {
-    regs[reg(args.b)] = portable.ctz_u64(regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = portable.ctz_u64(regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // TRAILING_ZERO_BITS_32
 export const trailing_zero_bits_32 = (r, args, regs) => {
-    regs[reg(args.b)] = u64(portable.ctz_u32(u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.b)] = u64(portable.ctz_u32(u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // SIGN_EXTEND_8
 export const sign_extend_8 = (r, args, regs) => {
-    regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u8SignExtend(u8(regs[Inst.reg(args.a)]));
+    return OutcomeData.ok(r);
 };
 // SIGN_EXTEND_16
 export const sign_extend_16 = (r, args, regs) => {
-    regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u16SignExtend(u16(regs[Inst.reg(args.a)]));
+    return OutcomeData.ok(r);
 };
 // ZERO_EXTEND_16
 export const zero_extend_16 = (r, args, regs) => {
-    regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));
-    return ok(r);
+    regs[Inst.reg(args.b)] = u64(u16(regs[Inst.reg(args.a)]));
+    return OutcomeData.ok(r);
 };
 // REVERSE_BYTES
 export const reverse_bytes = (r, args, regs) => {
-    regs[reg(args.b)] = portable.bswap_u64(regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = portable.bswap_u64(regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };

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

@@ -1,120 +1,120 @@
-import { ok, staticJump } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // BRANCH_EQ_IMM
 export const branch_eq_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] === b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] === b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_NE_IMM
 export const branch_ne_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] !== b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] !== b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LT_U_IMM
 export const branch_lt_u_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] < b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] < b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LE_U_IMM
 export const branch_le_u_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] <= b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] <= b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GE_U_IMM
 export const branch_ge_u_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] >= b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] >= b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GT_U_IMM
 export const branch_gt_u_imm = (r, args, registers) => {
-    const b = u64(u32SignExtend(args.b));
-    if (registers[reg(args.a)] > b) {
-        return staticJump(r, args.c);
+    const b = u64(Inst.u32SignExtend(args.b));
+    if (registers[Inst.reg(args.a)] > b) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LT_S_IMM
 export const branch_lt_s_imm = (r, args, registers) => {
-    if (i64(registers[reg(args.a)]) < i64(u32SignExtend(args.b))) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.a)]) < i64(Inst.u32SignExtend(args.b))) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LE_S_IMM
 export const branch_le_s_imm = (r, args, registers) => {
-    if (i64(registers[reg(args.a)]) <= i64(u32SignExtend(args.b))) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.a)]) <= i64(Inst.u32SignExtend(args.b))) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GE_S_IMM
 export const branch_ge_s_imm = (r, args, registers) => {
-    if (i64(registers[reg(args.a)]) >= i64(u32SignExtend(args.b))) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.a)]) >= i64(Inst.u32SignExtend(args.b))) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GT_S_IMM
 export const branch_gt_s_imm = (r, args, registers) => {
-    if (i64(registers[reg(args.a)]) > i64(u32SignExtend(args.b))) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.a)]) > i64(Inst.u32SignExtend(args.b))) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_EQ
 export const branch_eq = (r, args, registers) => {
-    if (registers[reg(args.a)] === registers[reg(args.b)]) {
-        return staticJump(r, args.c);
+    if (registers[Inst.reg(args.a)] === registers[Inst.reg(args.b)]) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_NE
 export const branch_ne = (r, args, registers) => {
-    if (registers[reg(args.a)] !== registers[reg(args.b)]) {
-        return staticJump(r, args.c);
+    if (registers[Inst.reg(args.a)] !== registers[Inst.reg(args.b)]) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LT_U
 export const branch_lt_u = (r, args, registers) => {
-    if (registers[reg(args.b)] < registers[reg(args.a)]) {
-        return staticJump(r, args.c);
+    if (registers[Inst.reg(args.b)] < registers[Inst.reg(args.a)]) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_LT_S
 export const branch_lt_s = (r, args, registers) => {
-    if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.b)]) < i64(registers[Inst.reg(args.a)])) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GE_U
 export const branch_ge_u = (r, args, registers) => {
-    if (registers[reg(args.b)] >= registers[reg(args.a)]) {
-        return staticJump(r, args.c);
+    if (registers[Inst.reg(args.b)] >= registers[Inst.reg(args.a)]) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // BRANCH_GE_S
 export const branch_ge_s = (r, args, registers) => {
-    if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {
-        return staticJump(r, args.c);
+    if (i64(registers[Inst.reg(args.b)]) >= i64(registers[Inst.reg(args.a)])) {
+        return OutcomeData.staticJump(r, args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };

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

@@ -1,21 +1,21 @@
 import { portable } from "../portable";
-import { dJump, staticJump } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // JUMP
-export const jump = (r, args) => staticJump(r, args.a);
+export const jump = (r, args) => OutcomeData.staticJump(r, args.a);
 // JUMP_IND
 export const jump_ind = (r, args, registers) => {
-    const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.b)));
-    return dJump(r, address);
+    const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.b)));
+    return OutcomeData.dJump(r, address);
 };
 // LOAD_IMM_JUMP
 export const load_imm_jump = (r, args, registers) => {
-    registers[reg(args.a)] = u32SignExtend(args.b);
-    return staticJump(r, args.c);
+    registers[Inst.reg(args.a)] = Inst.u32SignExtend(args.b);
+    return OutcomeData.staticJump(r, args.c);
 };
 // LOAD_IMM_JUMP_IND
 export const load_imm_jump_ind = (r, args, registers) => {
-    const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.d)));
-    registers[reg(args.b)] = u32SignExtend(args.c);
-    return dJump(r, address);
+    const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.d)));
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
+    return OutcomeData.dJump(r, address);
 };