@fluffylabs/anan-as 1.1.6 → 1.2.0-41e43f6

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

@@ -0,0 +1,362 @@
+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;
+};
+// Runtime binding for TS decorator emit in portable JS builds.
+const inline = (_target = 0, _propertyKey = 0, descriptor = 0) => descriptor;
+export class portable {
+    // @ts-ignore: @inline is an AS-only decorator
+    static installPolyfills() {
+        if (ASC_TARGET !== 0) {
+            return;
+        }
+        // @ts-ignore: JS runtime only
+        const g = globalThis;
+        if (g.__ananPortablePolyfillsInstalled) {
+            return;
+        }
+        g.__ananPortablePolyfillsInstalled = true;
+        // StaticArray -> Array with AS-like zero-initialized length constructor.
+        g.StaticArray = function StaticArray(length) {
+            const arr = new Array(length);
+            arr.fill(0);
+            return arr;
+        };
+        g.ASC_TARGET = 0;
+        g.i8 = (value) => {
+            const n = typeof value === "bigint" ? Number(value) : value;
+            return (n << 24) >> 24;
+        };
+        g.i16 = (value) => {
+            const n = typeof value === "bigint" ? Number(value) : value;
+            return (n << 16) >> 16;
+        };
+        const i32Fn = (value) => {
+            if (typeof value === "bigint") {
+                return Number(BigInt.asIntN(32, value));
+            }
+            return value | 0;
+        };
+        i32Fn.MIN_VALUE = -2147483648;
+        i32Fn.MAX_VALUE = 2147483647;
+        g.i32 = i32Fn;
+        const i64Fn = (value) => {
+            return BigInt.asIntN(64, BigInt(value));
+        };
+        i64Fn.MAX_VALUE = BigInt("9223372036854775807");
+        i64Fn.MIN_VALUE = BigInt("-9223372036854775808");
+        g.i64 = i64Fn;
+        g.u8 = (v) => {
+            if (typeof v === "bigint") {
+                return Number(v & BigInt(0xff)) >>> 0;
+            }
+            return (v & 0xff) >>> 0;
+        };
+        g.u16 = (v) => {
+            if (typeof v === "bigint") {
+                return Number(v & BigInt(0xffff)) >>> 0;
+            }
+            return (v & 0xffff) >>> 0;
+        };
+        g.u32 = (v) => {
+            if (typeof v === "bigint") {
+                return Number(v & BigInt(4294967295)) >>> 0;
+            }
+            return (v & 4294967295) >>> 0;
+        };
+        const u64Fn = (value) => {
+            return BigInt.asUintN(64, BigInt(value));
+        };
+        u64Fn.MAX_VALUE = BigInt("18446744073709551615");
+        u64Fn.MIN_VALUE = BigInt(0);
+        g.u64 = u64Fn;
+        g.f32 = (v) => Math.fround(v);
+        g.f64 = (v) => +v;
+        g.bool = (v) => !!v;
+        const dataViewProto = DataView.prototype;
+        if (!dataViewProto.setUint64) {
+            dataViewProto.setUint64 = function (byteOffset, value, littleEndian) {
+                const high = Number((value >> BigInt(32)) & BigInt(4294967295));
+                const low = Number(value & BigInt(4294967295));
+                if (littleEndian) {
+                    this.setUint32(byteOffset, low, true);
+                    this.setUint32(byteOffset + 4, high, true);
+                }
+                else {
+                    this.setUint32(byteOffset, high, false);
+                    this.setUint32(byteOffset + 4, low, false);
+                }
+            };
+        }
+        if (!dataViewProto.getUint64) {
+            dataViewProto.getUint64 = function (byteOffset, littleEndian) {
+                if (littleEndian) {
+                    const low = BigInt(this.getUint32(byteOffset, true));
+                    const high = BigInt(this.getUint32(byteOffset + 4, true));
+                    return (high << BigInt(32)) | low;
+                }
+                const high = BigInt(this.getUint32(byteOffset, false));
+                const low = BigInt(this.getUint32(byteOffset + 4, false));
+                return (high << BigInt(32)) | low;
+            };
+        }
+        g.unchecked = (v) => v;
+        g.inline = inline;
+        g.changetype = (v) => v;
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    // @ts-ignore: parameter type differs between AS and JS
+    static asArray(v) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: JS runtime - v is an iterator, convert to array
+            return Array.from(v);
+        }
+        return v;
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static arrayAt(v, i) {
+        if (ASC_TARGET === 0) {
+            return v[i];
+        }
+        return unchecked(v[i]);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static staticArrayAt(v, i) {
+        if (ASC_TARGET === 0) {
+            return v[i];
+        }
+        return unchecked(v[i]);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static asU32(v) {
+        if (ASC_TARGET === 0) {
+            return v >>> 0;
+        }
+        return v;
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static uint8ArrayView(data, offset, length) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: JS runtime supports Uint8Array(buffer, offset, length)
+            return new Uint8Array(data, offset, length);
+        }
+        // @ts-ignore: Uint8Array.wrap is an AS-only API
+        return Uint8Array.wrap(data, offset, length);
+    }
+    // --- bswap ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static bswap_u16(v) {
+        if (ASC_TARGET === 0) {
+            return u16(((v & 0xff) << 8) | ((v >> 8) & 0xff));
+        }
+        return bswap(v);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static bswap_u32(v) {
+        if (ASC_TARGET === 0) {
+            return u32(((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v >> 8) & 0xff00) | ((v >> 24) & 0xff));
+        }
+        return bswap(v);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static bswap_u64(v) {
+        if (ASC_TARGET === 0) {
+            const lo = u32(v);
+            const hi = u32(v >> u64(32));
+            const sLo = portable.bswap_u32(lo);
+            const sHi = portable.bswap_u32(hi);
+            return u64((u64(sLo) << u64(32)) | u64(sHi));
+        }
+        return bswap(v);
+    }
+    // --- popcnt ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static popcnt_u32(v) {
+        if (ASC_TARGET === 0) {
+            v = v - ((v >>> 1) & 0x55555555);
+            v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
+            return (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+        }
+        return popcnt(v);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static popcnt_u64(v) {
+        if (ASC_TARGET === 0) {
+            const lo = portable.popcnt_u32(u32(v));
+            const hi = portable.popcnt_u32(u32(v >> u64(32)));
+            return u64(lo + hi);
+        }
+        return popcnt(v);
+    }
+    // --- clz ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static clz_u32(v) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: Math.clz32 exists in ES2015+
+            return Math.clz32(v);
+        }
+        return clz(v);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static clz_u64(v) {
+        if (ASC_TARGET === 0) {
+            const hi = u32(v >> u64(32));
+            if (hi !== 0) {
+                return u64(portable.clz_u32(hi));
+            }
+            return u64(32 + portable.clz_u32(u32(v)));
+        }
+        return clz(v);
+    }
+    // --- ctz ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static ctz_u32(v) {
+        if (ASC_TARGET === 0) {
+            if (v === 0)
+                return 32;
+            // @ts-ignore: Math.clz32 exists in ES2015+
+            return (31 - Math.clz32(v & -v));
+        }
+        return ctz(v);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static ctz_u64(v) {
+        if (ASC_TARGET === 0) {
+            const lo = u32(v);
+            if (lo !== 0) {
+                return u64(portable.ctz_u32(lo));
+            }
+            return u64(32 + portable.ctz_u32(u32(v >> u64(32))));
+        }
+        return ctz(v);
+    }
+    // --- rotr ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static rotr_u32(v, shift) {
+        if (ASC_TARGET === 0) {
+            shift &= 31;
+            return u32((v >>> shift) | (v << (32 - shift)));
+        }
+        return rotr(v, shift);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static rotr_u64(v, shift) {
+        if (ASC_TARGET === 0) {
+            shift &= u64(63);
+            return u64((v >> shift) | (v << (u64(64) - shift)));
+        }
+        return rotr(v, shift);
+    }
+    // --- rotl ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static rotl_u32(v, shift) {
+        if (ASC_TARGET === 0) {
+            shift &= 31;
+            return u32((v << shift) | (v >>> (32 - shift)));
+        }
+        return rotl(v, shift);
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static rotl_u64(v, shift) {
+        if (ASC_TARGET === 0) {
+            shift &= u64(63);
+            return u64((v << shift) | (v >> (u64(64) - shift)));
+        }
+        return rotl(v, shift);
+    }
+    // --- u64 wrapping arithmetic ---
+    // @ts-ignore: @inline is an AS-only decorator
+    static u64_add(a, b) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: BigInt
+            return BigInt.asUintN(64, BigInt(a) + BigInt(b));
+        }
+        return a + b;
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static u64_sub(a, b) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: BigInt
+            return BigInt.asUintN(64, BigInt(a) - BigInt(b));
+        }
+        return a - b;
+    }
+    // @ts-ignore: @inline is an AS-only decorator
+    static u64_mul(a, b) {
+        if (ASC_TARGET === 0) {
+            // @ts-ignore: BigInt
+            return BigInt.asUintN(64, BigInt(a) * BigInt(b));
+        }
+        return a * b;
+    }
+}
+__decorate([
+    inline
+], portable, "installPolyfills", null);
+__decorate([
+    inline
+    // @ts-ignore: parameter type differs between AS and JS
+], portable, "asArray", null);
+__decorate([
+    inline
+], portable, "arrayAt", null);
+__decorate([
+    inline
+], portable, "staticArrayAt", null);
+__decorate([
+    inline
+], portable, "asU32", null);
+__decorate([
+    inline
+], portable, "uint8ArrayView", null);
+__decorate([
+    inline
+], portable, "bswap_u16", null);
+__decorate([
+    inline
+], portable, "bswap_u32", null);
+__decorate([
+    inline
+], portable, "bswap_u64", null);
+__decorate([
+    inline
+], portable, "popcnt_u32", null);
+__decorate([
+    inline
+], portable, "popcnt_u64", null);
+__decorate([
+    inline
+], portable, "clz_u32", null);
+__decorate([
+    inline
+], portable, "clz_u64", null);
+__decorate([
+    inline
+], portable, "ctz_u32", null);
+__decorate([
+    inline
+], portable, "ctz_u64", null);
+__decorate([
+    inline
+], portable, "rotr_u32", null);
+__decorate([
+    inline
+], portable, "rotr_u64", null);
+__decorate([
+    inline
+], portable, "rotl_u32", null);
+__decorate([
+    inline
+], portable, "rotl_u64", null);
+__decorate([
+    inline
+], portable, "u64_add", null);
+__decorate([
+    inline
+], portable, "u64_sub", null);
+__decorate([
+    inline
+], portable, "u64_mul", null);
+portable.installPolyfills();

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

@@ -0,0 +1,2 @@
+/** Turn given bytecode into a valid program. Add JumpTable and Mask. */
+export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array;

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

@@ -0,0 +1,104 @@
+import { Arguments, higNibble, lowNibble, REQUIRED_BYTES } from "./arguments";
+import { encodeVarU32 } from "./codec";
+import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
+import { minI32 } from "./math";
+/** Turn given bytecode into a valid program. Add JumpTable and Mask. */
+export function wrapAsProgram(bytecode) {
+    const jumpTableLength = 0;
+    const jumpTableItemLength = 0;
+    const codeLength = bytecode.length;
+    const mask = buildMask(bytecode);
+    const codeLengthBytes = encodeVarU32(codeLength);
+    const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);
+    data[0] = jumpTableLength;
+    data[1] = jumpTableItemLength;
+    let offset = 2;
+    for (let i = 0; i < codeLengthBytes.length; i++) {
+        data[offset] = codeLengthBytes[i];
+        offset++;
+    }
+    for (let i = 0; i < bytecode.length; i++) {
+        data[offset] = bytecode[i];
+        offset++;
+    }
+    for (let i = 0; i < mask.length; i++) {
+        data[offset] = mask[i];
+        offset++;
+    }
+    return data;
+}
+function skipBytes(kind, data) {
+    switch (kind) {
+        case Arguments.Zero:
+            return 0;
+        case Arguments.OneImm:
+            return immBytes(data.length, 0);
+        case Arguments.TwoImm: {
+            const low = lowNibble(data[0]);
+            const split = low + 1;
+            return 1 + split + immBytes(data.length, split + 1);
+        }
+        case Arguments.OneOff:
+            return immBytes(data.length, 0);
+        case Arguments.OneRegOneImm:
+            return 1 + immBytes(data.length, 1);
+        case Arguments.OneRegOneExtImm:
+            return 9;
+        case Arguments.OneRegTwoImm: {
+            const hig = higNibble(data[0]);
+            const split = hig + 1;
+            return 1 + split + immBytes(data.length, 1 + split);
+        }
+        case Arguments.OneRegOneImmOneOff: {
+            const hig = higNibble(data[0]);
+            const split = hig + 1;
+            return 1 + split + immBytes(data.length, 1 + split);
+        }
+        case Arguments.TwoReg:
+            return 1;
+        case Arguments.TwoRegOneImm:
+            return 1 + minI32(4, data.length);
+        case Arguments.TwoRegOneOff:
+            return 1 + minI32(4, data.length);
+        case Arguments.TwoRegTwoImm: {
+            const low = lowNibble(data[1]);
+            const split = low + 1;
+            return 2 + split + immBytes(data.length, 2 + split);
+        }
+        case Arguments.ThreeReg:
+            return 2;
+        default:
+            throw new Error(`Unhandled arguments kind: ${kind}`);
+    }
+}
+function buildMask(bytecode) {
+    const mask = new StaticArray(bytecode.length);
+    for (let i = 0; i < bytecode.length; i++) {
+        const instruction = bytecode[i];
+        const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;
+        mask[i] = true;
+        const requiredBytes = REQUIRED_BYTES[iData.kind];
+        if (i + 1 + requiredBytes <= bytecode.length) {
+            i += skipBytes(iData.kind, bytecode.subarray(i + 1));
+        }
+    }
+    // pack mask
+    const packed = [];
+    for (let i = 0; i < mask.length; i += 8) {
+        let byte = 0;
+        for (let j = i; j < i + 8; j++) {
+            byte >>= 1;
+            if (j < mask.length && mask[j]) {
+                byte |= 128;
+            }
+        }
+        packed.push(byte);
+    }
+    return packed;
+}
+function immBytes(dataLength, required) {
+    if (dataLength < required) {
+        return 0;
+    }
+    return minI32(4, dataLength - required);
+}

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

@@ -0,0 +1,78 @@
+import { Args, Arguments } from "./arguments";
+import { Registers } from "./registers";
+export type ProgramCounter = u32;
+export declare class CodeAndMetadata {
+    readonly code: Uint8Array;
+    readonly metadata: Uint8Array;
+    constructor(code: Uint8Array, metadata: Uint8Array);
+}
+/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */
+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[];
+/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */
+export declare function deblob(program: Uint8Array): Program;
+/**
+ * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5
+ */
+export declare class Mask {
+    /**
+     * NOTE: might be longer than code (bit-alignment).
+     * In this array we keep `skip(n) + 1` from the Gray Paper
+     * for non-instruction bytes.
+     * In case the in-code mask says there is an instruction at that location
+     * we store `0` here.
+     */
+    readonly bytesToSkip: StaticArray<u32>;
+    constructor(packedMask: Uint8Array, codeLength: i32);
+    isInstruction(index: ProgramCounter): boolean;
+    /**
+     * Given we are at instruction `i`, how many bytes should be skipped to
+     * reach the next instruction (i.e. `skip(i) + 1` from the GP).
+     *
+     * NOTE: we don't guarantee that `isInstruction()` will return true
+     * for the new program counter, since `skip` function is bounded by
+     * an upper limit of `24` bytes.
+     */
+    skipBytesToNextInstruction(i: u32): u32;
+    toString(): string;
+}
+export declare enum BasicBlock {
+    NONE = 0,
+    START = 2,
+    END = 4
+}
+/**
+ * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5
+ */
+export declare class BasicBlocks {
+    readonly isStartOrEnd: StaticArray<BasicBlock>;
+    constructor(code: u8[], mask: Mask);
+    isStart(newPc: u32): boolean;
+    toString(): string;
+}
+export declare class JumpTable {
+    readonly jumps: StaticArray<u64>;
+    constructor(itemBytes: u8, data: Uint8Array);
+    toString(): string;
+}
+export declare class Program {
+    readonly code: u8[];
+    readonly mask: Mask;
+    readonly jumpTable: JumpTable;
+    readonly basicBlocks: BasicBlocks;
+    constructor(code: u8[], mask: Mask, jumpTable: JumpTable, basicBlocks: BasicBlocks);
+    toString(): string;
+}
+export declare function decodeArguments(args: Args, kind: Arguments, code: u8[], offset: i32, lim: u32): Args;
+declare class ResolvedArguments {
+    a: i64;
+    b: i64;
+    c: i64;
+    d: i64;
+    decoded: Args;
+}
+export declare function resolveArguments(argsRes: Args, kind: Arguments, code: u8[], offset: u32, lim: u32, registers: Registers): ResolvedArguments | null;
+export {};