@fluffylabs/anan-as 1.2.0 → 1.3.0-5cbd3aa

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

@@ -0,0 +1,221 @@
+import { buildMemory, getAssembly, vmDestroy, vmExecute, vmInit, vmRunOnce } from "./api-internal";
+import { VmInput, VmPause, VmRunOptions } from "./api-types";
+import { MaybePageFault, MemoryBuilder } from "./memory";
+import { deblob, extractCodeAndMetadata, liftBytes } from "./program";
+import { NO_OF_REGISTERS, newRegisters } from "./registers";
+import { decodeSpi, StandardProgram } from "./spi";
+export var InputKind;
+(function (InputKind) {
+    InputKind[InputKind["Generic"] = 0] = "Generic";
+    InputKind[InputKind["SPI"] = 1] = "SPI";
+})(InputKind || (InputKind = {}));
+export var HasMetadata;
+(function (HasMetadata) {
+    HasMetadata[HasMetadata["Yes"] = 0] = "Yes";
+    HasMetadata[HasMetadata["No"] = 1] = "No";
+})(HasMetadata || (HasMetadata = {}));
+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, false);
+    let output = "";
+    if (withMetadata === HasMetadata.Yes) {
+        output = "Metadata: \n";
+        output += "0x";
+        output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, "0"), "");
+        output += "\n\n";
+    }
+    output += getAssembly(program.program);
+    return output;
+}
+export function prepareProgram(kind, hasMetadata, program, 
+/** NOTE: ignored in case of SPI. */
+initialRegisters, 
+/** NOTE: ignored in case of SPI. */
+initialPageMap, 
+/** NOTE: ignored in case of SPI. */
+initialMemory, 
+/** NOTE: ONLY needed for SPI. */
+args, 
+/** Preallocate a bunch of memory pages for faster execution. */
+preallocateMemoryPages, 
+/** Compute gas per-block instead of per-instruction. */
+useBlockGas) {
+    let code = liftBytes(program);
+    let metadata = new Uint8Array(0);
+    if (hasMetadata === HasMetadata.Yes) {
+        const data = extractCodeAndMetadata(code);
+        // @ts-ignore: TS 5.9 Uint8Array generic parameter mismatch
+        code = data.code;
+        // @ts-ignore: TS 5.9 Uint8Array generic parameter mismatch
+        metadata = data.metadata;
+    }
+    if (kind === InputKind.Generic) {
+        const program = deblob(code, useBlockGas);
+        const builder = new MemoryBuilder(preallocateMemoryPages);
+        const memory = buildMemory(builder, initialPageMap, initialMemory);
+        const registers = newRegisters();
+        const safeLen = initialRegisters.length < NO_OF_REGISTERS ? initialRegisters.length : NO_OF_REGISTERS;
+        for (let r = 0; r < safeLen; r++) {
+            registers[r] = initialRegisters[r];
+        }
+        const exe = new StandardProgram(program, memory, registers);
+        exe.metadata = metadata;
+        return exe;
+    }
+    if (kind === InputKind.SPI) {
+        const exe = decodeSpi(code, liftBytes(args), preallocateMemoryPages);
+        exe.metadata = metadata;
+        return exe;
+    }
+    throw new Error(`Unknown kind: ${kind}`);
+}
+/** Execute PVM program and stop. */
+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.dumpMemory = dumpMemory;
+    return vmRunOnce(vmInput, vmOptions);
+}
+/** Next available pvm id. */
+let nextPvmId = 0;
+/** Currently allocated pvms. */
+const pvms = new Map();
+/**
+ * Allocate new PVM instance to execute given program.
+ *
+ * NOTE: the PVM MUST be de-allocated using `pvmDestroy`.
+ */
+export function pvmStart(program) {
+    const vmInput = new VmInput(program.program, program.memory, program.registers);
+    nextPvmId += 1;
+    pvms.set(nextPvmId, vmInit(vmInput));
+    return nextPvmId;
+}
+/** Deallocate PVM resources. */
+export function pvmDestroy(pvmId) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        pvms.delete(pvmId);
+        return vmDestroy(int, false);
+    }
+    return null;
+}
+/** Set register values of a paused PVM. */
+export function pvmSetRegisters(pvmId, registers) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        const safeIter = registers.length < NO_OF_REGISTERS ? registers.length : NO_OF_REGISTERS;
+        for (let i = 0; i < safeIter; i++) {
+            int.registers[i] = registers[i];
+        }
+    }
+}
+/**
+ * Read a continuous chunk of memory from given PVM instance.
+ *
+ * @deprecated Use `pvmGetPagePointer` instead to read memory directly from WASM linear memory
+ * on the JS side with no additional WASM-side allocations.
+ */
+export function pvmReadMemory(pvmId, address, length) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        const faultRes = new MaybePageFault();
+        const result = int.memory.getMemory(faultRes, address, length);
+        if (!faultRes.isFault) {
+            return result;
+        }
+    }
+    return null;
+}
+/**
+ * Returns the WASM linear memory pointer (byte offset) for the backing buffer of the page at `page`
+ * in the given PVM instance.
+ *
+ * Returns `0` if the PVM does not exist, the page does not exist, or the page is not readable.
+ *
+ * Use this instead of `pvmReadMemory` to read memory efficiently from the JS side:
+ * ```ts
+ * let pagesRead = 0;
+ * for (let address = start; address < end; address += PAGE_SIZE) {
+ *   const page = address >> PAGE_SIZE_SHIFT;
+ *   const ptr = pvmGetPagePointer(pvmId, page);
+ *   if (ptr === 0) {
+ *     throw new Error(`Page fault at ${page << PAGE_SIZE_SHIFT}`);
+ *   }
+ *   destination.set(
+ *     new Uint8Array(wasm.instance.exports.memory.buffer, ptr, Math.min(end - address, PAGE_SIZE)),
+ *     pagesRead << PAGE_SIZE_SHIFT,
+ *   );
+ *   pagesRead += 1;
+ * }
+ * ```
+ */
+export function pvmGetPagePointer(pvmId, page) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        return int.memory.getPagePointer(page);
+    }
+    return 0;
+}
+/** Write a chunk of memory to given PVM instance. */
+export function pvmWriteMemory(pvmId, address, data) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        const faultRes = new MaybePageFault();
+        // Preflight: verify the entire target range is accessible before writing
+        const tempBuffer = new Uint8Array(data.length);
+        int.memory.bytesRead(faultRes, address, tempBuffer, 0);
+        if (faultRes.isFault) {
+            return false;
+        }
+        // Now perform the actual write
+        faultRes.isFault = false;
+        faultRes.isAccess = false;
+        int.memory.bytesWrite(faultRes, address, data, 0);
+        if (!faultRes.isFault) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Resume execution of paused VM. */
+export function pvmResume(pvmId, gas, pc, logs = false) {
+    if (pvms.has(pvmId)) {
+        const int = pvms.get(pvmId);
+        int.nextPc = pc;
+        int.gas.set(gas);
+        vmExecute(int, logs);
+        const pause = new VmPause();
+        pause.status = int.status;
+        pause.exitCode = int.exitCode;
+        pause.pc = int.pc;
+        pause.nextPc = int.nextPc;
+        pause.gas = int.gas.get();
+        pause.registers = int.registers.slice(0);
+        return pause;
+    }
+    return null;
+}

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

@@ -0,0 +1,44 @@
+export declare enum Arguments {
+    Zero = 0,
+    OneImm = 1,
+    TwoImm = 2,
+    OneOff = 3,
+    OneRegOneImm = 4,
+    OneRegOneExtImm = 5,
+    OneRegTwoImm = 6,
+    OneRegOneImmOneOff = 7,
+    TwoReg = 8,
+    TwoRegOneImm = 9,
+    TwoRegOneOff = 10,
+    TwoRegTwoImm = 11,
+    ThreeReg = 12
+}
+/** How many numbers in `Args` is relevant for given `Arguments`. */
+export declare const RELEVANT_ARGS: StaticArray<i32>;
+/** How many bytes is required by given `Arguments`. */
+export declare const REQUIRED_BYTES: StaticArray<i32>;
+export declare class Args {
+    fill(a: u32, b?: u32, c?: u32, d?: u32): Args;
+    /**
+     * TwoReg: `omega_A`
+     * TwoRegOneOff: `omega_B`
+     * ThreeReg: `omega_B`
+     */
+    a: u32;
+    /**
+     * TwoReg: `omega'_D`
+     * TwoRegOneOff: `omega'_A`
+     * ThreeReg: `omega_A`
+     */
+    b: u32;
+    /**
+     * ThreeReg: `omega'_D`
+     */
+    c: u32;
+    d: u32;
+}
+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

@@ -0,0 +1,164 @@
+import { IntMath } from "./math";
+import { portable } from "./portable";
+export var Arguments;
+(function (Arguments) {
+    Arguments[Arguments["Zero"] = 0] = "Zero";
+    Arguments[Arguments["OneImm"] = 1] = "OneImm";
+    Arguments[Arguments["TwoImm"] = 2] = "TwoImm";
+    Arguments[Arguments["OneOff"] = 3] = "OneOff";
+    Arguments[Arguments["OneRegOneImm"] = 4] = "OneRegOneImm";
+    Arguments[Arguments["OneRegOneExtImm"] = 5] = "OneRegOneExtImm";
+    Arguments[Arguments["OneRegTwoImm"] = 6] = "OneRegTwoImm";
+    Arguments[Arguments["OneRegOneImmOneOff"] = 7] = "OneRegOneImmOneOff";
+    Arguments[Arguments["TwoReg"] = 8] = "TwoReg";
+    Arguments[Arguments["TwoRegOneImm"] = 9] = "TwoRegOneImm";
+    Arguments[Arguments["TwoRegOneOff"] = 10] = "TwoRegOneOff";
+    Arguments[Arguments["TwoRegTwoImm"] = 11] = "TwoRegTwoImm";
+    Arguments[Arguments["ThreeReg"] = 12] = "ThreeReg";
+})(Arguments || (Arguments = {}));
+/** How many numbers in `Args` is relevant for given `Arguments`. */
+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 = StaticArray.fromArray([0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2]);
+// @unmanaged
+export class Args {
+    constructor() {
+        /**
+         * TwoReg: `omega_A`
+         * TwoRegOneOff: `omega_B`
+         * ThreeReg: `omega_B`
+         */
+        this.a = 0;
+        /**
+         * TwoReg: `omega'_D`
+         * TwoRegOneOff: `omega'_A`
+         * ThreeReg: `omega_A`
+         */
+        this.b = 0;
+        /**
+         * ThreeReg: `omega'_D`
+         */
+        this.c = 0;
+        this.d = 0;
+    }
+    fill(a, b = 0, c = 0, d = 0) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        return this;
+    }
+}
+function twoImm(args, code, offset, end) {
+    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 = StaticArray.fromArray([
+    // DECODERS[Arguments.Zero] =
+    (args, _d, _o, _l) => {
+        return args.fill(0, 0, 0, 0);
+    },
+    // DECODERS[Arguments.OneImm] =
+    (args, data, o, lim) => {
+        return args.fill(decodeI32(data, o, lim), 0, 0, 0);
+    },
+    // DECODERS[Arguments.TwoImm] =
+    (args, data, o, lim) => twoImm(args, data, o, lim),
+    // DECODERS[Arguments.OneOff] =
+    (args, data, o, lim) => {
+        return args.fill(decodeI32(data, o, lim), 0, 0, 0);
+    },
+    // DECODERS[Arguments.OneRegOneImm] =
+    (args, data, o, lim) => {
+        return args.fill(lowNibble(data[o]), decodeI32(data, o + 1, lim), 0, 0);
+    },
+    // DECODERS[Arguments.OneRegOneExtImm] =
+    (args, data, o, _lim) => {
+        const a = lowNibble(data[o]);
+        const b = decodeU32(data, o + 1);
+        const c = decodeU32(data, o + 5);
+        return args.fill(a, b, c, 0);
+    },
+    //DECODERS[Arguments.OneRegTwoImm] =
+    (args, data, o, lim) => {
+        const h = higNibble(data[o]);
+        const l = lowNibble(data[o]);
+        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);
+    },
+    // DECODERS[Arguments.OneRegOneImmOneOff] =
+    (args, data, o, lim) => {
+        const h = higNibble(data[o]);
+        const l = lowNibble(data[o]);
+        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);
+    },
+    // DECODERS[Arguments.TwoReg] =
+    (args, data, o, _lim) => {
+        return args.fill(higNibble(data[o]), lowNibble(data[o]), 0, 0);
+    },
+    // DECODERS[Arguments.TwoRegOneImm] =
+    (args, data, o, lim) => {
+        const hig = higNibble(data[o]);
+        const low = lowNibble(data[o]);
+        return args.fill(hig, low, decodeI32(data, o + 1, lim), 0);
+    },
+    // DECODERS[Arguments.TwoRegOneOff] =
+    (args, data, o, lim) => {
+        const hig = higNibble(data[o]);
+        const low = lowNibble(data[o]);
+        return args.fill(hig, low, decodeI32(data, o + 1, lim), 0);
+    },
+    // DECODERS[Arguments.TwoRegTwoImm] =
+    (args, data, o, lim) => {
+        const hig = higNibble(data[o]);
+        const low = lowNibble(data[o]);
+        const result = twoImm(args, data, o + 1, lim);
+        return args.fill(hig, low, result.a, result.b);
+    },
+    // DECODERS[Arguments.ThreeReg] =
+    (args, data, o, _lim) => {
+        const hig = higNibble(data[o]);
+        const low = lowNibble(data[o]);
+        const b = lowNibble(data[o + 1]);
+        return args.fill(hig, low, b, 0);
+    },
+]);
+// @inline
+export function lowNibble(byte) {
+    return byte & 0xf;
+}
+export function higNibble(byte) {
+    return byte >> 4;
+}
+//@inline
+function decodeI32(input, start, end) {
+    if (end <= start) {
+        return 0;
+    }
+    const l = end - start;
+    const len = l < 4 ? l : 4;
+    let num = 0x0;
+    for (let i = 0; i < len; i++) {
+        num |= u32(input[start + i]) << (i * 8);
+    }
+    const msb = portable.staticArrayAt(input, start + len - 1) & 0x80;
+    if (len < 4 && msb > 0) {
+        num |= 4294967295 << (len * 8);
+    }
+    return num;
+}
+function decodeU32(data, offset) {
+    let num = u32(data[offset + 0]);
+    num |= u32(data[offset + 1]) << 8;
+    num |= u32(data[offset + 2]) << 16;
+    num |= u32(data[offset + 3]) << 24;
+    return portable.asU32(num);
+}

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

@@ -0,0 +1,24 @@
+export declare class Decoder {
+    private readonly source;
+    private offset;
+    constructor(source: Uint8Array, offset?: i32);
+    isExhausted(): boolean;
+    private ensureBytes;
+    finish(): void;
+    varU32(): u32;
+    u8(): u8;
+    u16(): u16;
+    u24(): u32;
+    u32(): u32;
+    bytes(len: i32): Uint8Array;
+    /** Read remaining bytes into Uint8Array */
+    remainingBytes(): Uint8Array;
+}
+export declare class ValOffset<T> {
+    readonly value: T;
+    readonly offset: i32;
+    constructor(value: T, offset: i32);
+}
+/** Read variable-length u32 and return number of bytes read. */
+export declare function decodeVarU32(data: Uint8Array): ValOffset<u32>;
+export declare function encodeVarU32(v: u64): Uint8Array;

package/dist/build/js/assembly/codec.js

@@ -0,0 +1,139 @@
+const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];
+const variableLength = (firstByte) => {
+    const len = MASKS.length;
+    for (let i = 0; i < len; i++) {
+        if (firstByte >= MASKS[i]) {
+            return 8 - i;
+        }
+    }
+    return 0;
+};
+export class Decoder {
+    constructor(source, offset = 0) {
+        this.source = source;
+        this.offset = offset;
+    }
+    isExhausted() {
+        return this.offset >= this.source.length;
+    }
+    ensureBytes(need) {
+        if (this.offset + need > this.source.length) {
+            throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);
+        }
+    }
+    finish() {
+        if (!this.isExhausted()) {
+            throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);
+        }
+    }
+    varU32() {
+        this.ensureBytes(1);
+        const v = decodeVarU32(this.source.subarray(this.offset));
+        this.offset += v.offset;
+        return v.value;
+    }
+    u8() {
+        this.ensureBytes(1);
+        const v = this.source[this.offset];
+        this.offset += 1;
+        return v;
+    }
+    u16() {
+        this.ensureBytes(2);
+        let v = this.source[this.offset];
+        v |= u16(this.source[this.offset + 1]) << 8;
+        this.offset += 2;
+        return v;
+    }
+    u24() {
+        this.ensureBytes(3);
+        let v = this.source[this.offset];
+        v |= u32(this.source[this.offset + 1]) << 8;
+        v |= u32(this.source[this.offset + 2]) << 16;
+        this.offset += 3;
+        return v;
+    }
+    u32() {
+        this.ensureBytes(4);
+        let v = this.source[this.offset];
+        v |= u32(this.source[this.offset + 1]) << 8;
+        v |= u32(this.source[this.offset + 2]) << 16;
+        v |= u32(this.source[this.offset + 3]) << 24;
+        this.offset += 4;
+        return v;
+    }
+    bytes(len) {
+        this.ensureBytes(len);
+        const v = this.source.subarray(this.offset, this.offset + len);
+        this.offset += len;
+        return v;
+    }
+    /** Read remaining bytes into Uint8Array */
+    remainingBytes() {
+        const v = this.source.subarray(this.offset);
+        this.offset += v.length;
+        return v;
+    }
+}
+// @unmanaged
+export class ValOffset {
+    constructor(value, offset) {
+        this.value = value;
+        this.offset = offset;
+    }
+}
+/** Read variable-length u32 and return number of bytes read. */
+export function decodeVarU32(data) {
+    const length = i32(variableLength(data[0]));
+    const first = u32(data[0]);
+    if (length === 0) {
+        return new ValOffset(first, 1);
+    }
+    if (data.length < length) {
+        throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);
+    }
+    const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);
+    let number = 0;
+    for (let i = length - 1; i >= 0; i--) {
+        number = (number << 8) + data[1 + i];
+    }
+    number += msb;
+    return new ValOffset(number, 1 + length);
+}
+export function encodeVarU32(v) {
+    v = u64(v);
+    if (v === u64(0)) {
+        return new Uint8Array(1);
+    }
+    // handle the biggest case
+    let maxEncoded = u64(2 ** (7 * 8));
+    if (v >= maxEncoded) {
+        const dest = new Uint8Array(9);
+        dest[0] = 0xff;
+        const dataView = new DataView(dest.buffer);
+        dataView.setUint64(1, v, true);
+        return dest;
+    }
+    // let's look for the correct range
+    let minEncoded = maxEncoded >> u64(7);
+    for (let l = 7; l >= 0; l -= 1) {
+        if (v >= minEncoded) {
+            const dest = new Uint8Array(l + 1);
+            // encode the first byte
+            const maxVal = u64(2 ** (8 * l));
+            const byte = (u32(2 ** 8 - 2 ** (8 - l)) + u32(v / maxVal)) & 4294967295;
+            dest[0] = u8(byte);
+            // now encode the rest of bytes of len `l`
+            let rest = v % maxVal;
+            for (let i = 1; i < 1 + l; i += 1) {
+                dest[i] = u8(rest);
+                rest >>= u64(8);
+            }
+            return dest;
+        }
+        // move one power down
+        maxEncoded = minEncoded;
+        minEncoded >>= u64(7);
+    }
+    throw new Error(`Unhandled number encoding: ${v}`);
+}

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

@@ -0,0 +1,11 @@
+/** Gas type. */
+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;
+    get(): Gas;
+    sub(g: u32): boolean;
+}

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

@@ -0,0 +1,33 @@
+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 GasCounter(gas);
+}
+export class GasCounter {
+    constructor(gas) {
+        this.gas = gas;
+    }
+    set(g) {
+        this.gas = g;
+    }
+    get() {
+        return this.gas;
+    }
+    sub(g) {
+        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/index-shared.d.ts

@@ -0,0 +1,4 @@
+export * from "./api-debugger";
+export { getAssembly } from "./api-internal";
+export * from "./api-utils";
+export { wrapAsProgram } from "./program-build";

package/dist/build/js/assembly/index-shared.js

@@ -0,0 +1,4 @@
+export * from "./api-debugger";
+export { getAssembly } from "./api-internal";
+export * from "./api-utils";
+export { wrapAsProgram } from "./program-build";

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

@@ -0,0 +1,11 @@
+import { InstructionRun } from "./outcome";
+export declare const count_set_bits_64: InstructionRun;
+export declare const count_set_bits_32: InstructionRun;
+export declare const leading_zero_bits_64: InstructionRun;
+export declare const leading_zero_bits_32: InstructionRun;
+export declare const trailing_zero_bits_64: InstructionRun;
+export declare const trailing_zero_bits_32: InstructionRun;
+export declare const sign_extend_8: InstructionRun;
+export declare const sign_extend_16: InstructionRun;
+export declare const zero_extend_16: InstructionRun;
+export declare const reverse_bytes: InstructionRun;