@fluffylabs/anan-as 1.2.0-41e43f6 → 1.2.0-5196d29

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { Args, Arguments, DECODERS, REQUIRED_BYTES } from "./arguments";
 import { Decoder } from "./codec";
 import { INSTRUCTIONS, MISSING_INSTRUCTION } from "./instructions";
-import { reg, u32SignExtend } from "./instructions/utils";
+import { Inst } from "./instructions/utils";
 import { portable } from "./portable";
 const MAX_SKIP = 24;
 export class CodeAndMetadata {
@@ -24,16 +24,16 @@ export function liftBytes(data) {
     p.set(data, 0);
     return p;
 }
-/**  Convert `Uint8Array` to `u8` */
+/**  Convert `Uint8Array` to `Code` (StaticArray<u8>) */
 export function lowerBytes(data) {
-    const r = new Array(data.length);
+    const r = new StaticArray(data.length);
     for (let i = 0; i < data.length; i++) {
         r[i] = data[i];
     }
     return r;
 }
 /** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */
-export function deblob(program) {
+export function deblob(program, useBlockGas) {
     const decoder = new Decoder(program);
     // number of items in the jump table
     const jumpTableLength = decoder.varU32();
@@ -50,7 +50,8 @@ export function deblob(program) {
     const mask = new Mask(rawMask, codeLength);
     const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);
     const basicBlocks = new BasicBlocks(rawCode, mask);
-    return new Program(rawCode, mask, jumpTable, basicBlocks);
+    const gasCosts = new GasCosts(rawCode, mask, basicBlocks, useBlockGas);
+    return new Program(rawCode, mask, jumpTable, basicBlocks, gasCosts);
 }
 /**
  * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5
@@ -100,6 +101,54 @@ export class Mask {
         return `${v}]`;
     }
 }
+export class GasCosts {
+    constructor(code, mask, blocks, useBlockGasCost) {
+        const len = code.length;
+        const costs = new StaticArray(len);
+        for (let n = 0; n < len; n += 1) {
+            const isInstructionInMask = mask.isInstruction(n);
+            if (!isInstructionInMask) {
+                costs[n] = code[n];
+                continue;
+            }
+            const skipArgs = mask.skipBytesToNextInstruction(n);
+            const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];
+            costs[n] = code[n] | (iData.gas << 8);
+            n += skipArgs;
+        }
+        // sum up costs per block
+        if (useBlockGasCost) {
+            let previousStart = 0;
+            let previousSum = 0;
+            for (let n = 0; n < len; n += 1) {
+                const currentGas = costs[n] >> 8;
+                costs[n] = code[n]; // reset to just opcode (gas=0)
+                if (blocks.isStart(n)) {
+                    costs[previousStart] = code[previousStart] | (previousSum << 8);
+                    previousSum = currentGas;
+                    previousStart = n;
+                }
+                else {
+                    previousSum += currentGas;
+                }
+                n += mask.skipBytesToNextInstruction(n);
+            }
+            // final assignment
+            costs[previousStart] = code[previousStart] | (previousSum << 8);
+        }
+        this.codeAndGas = costs;
+    }
+    toString() {
+        let v = "GasCosts[";
+        for (let i = 0; i < this.codeAndGas.length; i += 1) {
+            const gas = this.codeAndGas[i] >> 8;
+            if (gas !== 0) {
+                v += `${i} -> ${gas}, `;
+            }
+        }
+        return `${v}]`;
+    }
+}
 export var BasicBlock;
 (function (BasicBlock) {
     BasicBlock[BasicBlock["NONE"] = 0] = "NONE";
@@ -185,32 +234,33 @@ export class JumpTable {
     }
 }
 export class Program {
-    constructor(code, mask, jumpTable, basicBlocks) {
+    constructor(code, mask, jumpTable, basicBlocks, gasCosts) {
         this.code = code;
         this.mask = mask;
         this.jumpTable = jumpTable;
         this.basicBlocks = basicBlocks;
+        this.gasCosts = gasCosts;
     }
     toString() {
-        return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;
+        return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks}, gasCosts: ${this.gasCosts} }`;
     }
 }
 // Pre-allocated buffer for the rare case when code is shorter than needed.
 // Max REQUIRED_BYTES is 9 (OneRegOneExtImm). We allocate 16 for safety.
-const EXTENDED_BUF = new Array(16);
+const EXTENDED_BUF = new StaticArray(16);
 export function decodeArguments(args, kind, code, offset, lim) {
     if (code.length < offset + REQUIRED_BYTES[kind]) {
         // in case we have less data than needed we extend the data with zeros.
-        const reqBytes = REQUIRED_BYTES[kind];
+        const reqBytes = unchecked(REQUIRED_BYTES[kind]);
         for (let i = 0; i < reqBytes; i++) {
             EXTENDED_BUF[i] = 0;
         }
         for (let i = offset; i < code.length; i++) {
-            EXTENDED_BUF[i - offset] = code[i];
+            EXTENDED_BUF[i - offset] = unchecked(code[i]);
         }
-        return DECODERS[kind](args, EXTENDED_BUF, 0, lim);
+        return unchecked(DECODERS[kind])(args, EXTENDED_BUF, 0, lim);
     }
-    return DECODERS[kind](args, code, offset, offset + lim);
+    return unchecked(DECODERS[kind])(args, code, offset, offset + lim);
 }
 class ResolvedArguments {
     constructor() {
@@ -232,57 +282,57 @@ export function resolveArguments(argsRes, kind, code, offset, lim, registers) {
         case Arguments.Zero:
             return resolved;
         case Arguments.OneImm:
-            resolved.a = u32SignExtend(args.a);
+            resolved.a = Inst.u32SignExtend(args.a);
             return resolved;
         case Arguments.TwoImm:
-            resolved.a = u32SignExtend(args.a);
-            resolved.b = u32SignExtend(args.b);
+            resolved.a = Inst.u32SignExtend(args.a);
+            resolved.b = Inst.u32SignExtend(args.b);
             return resolved;
         case Arguments.OneOff:
-            resolved.a = u32SignExtend(args.a);
+            resolved.a = Inst.u32SignExtend(args.a);
             return resolved;
         case Arguments.OneRegOneImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
             return resolved;
         case Arguments.OneRegOneExtImm:
-            resolved.a = registers[reg(u64(args.a))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
             resolved.b = portable.u64_add(u64(args.a) << u64(32), u64(args.b));
             return resolved;
         case Arguments.OneRegTwoImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.OneRegOneImmOneOff:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = u32SignExtend(args.b);
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = Inst.u32SignExtend(args.b);
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoReg:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
             return resolved;
         case Arguments.TwoRegOneImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoRegOneOff:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
             return resolved;
         case Arguments.TwoRegTwoImm:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = u32SignExtend(args.c);
-            resolved.d = u32SignExtend(args.d);
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = Inst.u32SignExtend(args.c);
+            resolved.d = Inst.u32SignExtend(args.d);
             return resolved;
         case Arguments.ThreeReg:
-            resolved.a = registers[reg(u64(args.a))];
-            resolved.b = registers[reg(u64(args.b))];
-            resolved.c = registers[reg(u64(args.c))];
+            resolved.a = registers[Inst.reg(u64(args.a))];
+            resolved.b = registers[Inst.reg(u64(args.b))];
+            resolved.c = registers[Inst.reg(u64(args.c))];
             return resolved;
         default:
             throw new Error(`Unhandled arguments kind: ${kind}`);

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

@@ -8,7 +8,7 @@ export declare const ARGS_SEGMENT_START: u32;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */
 export declare const STACK_SEGMENT_END: u32;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */
-export declare function decodeSpi(data: Uint8Array, args: Uint8Array, preallocateMemoryPages?: u32): StandardProgram;
+export declare function decodeSpi(data: Uint8Array, args: Uint8Array, preallocateMemoryPages?: u32, useBlockGas?: boolean): StandardProgram;
 /**
  * SPI Program with memory and registers.
  *

package/dist/build/js/assembly/spi.js

@@ -10,7 +10,7 @@ export const ARGS_SEGMENT_START = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */
 export const STACK_SEGMENT_END = ARGS_SEGMENT_START - SEGMENT_SIZE;
 /** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */
-export function decodeSpi(data, args, preallocateMemoryPages = 0) {
+export function decodeSpi(data, args, preallocateMemoryPages = 0, useBlockGas = false) {
     const argsLength = args.length;
     if (argsLength > MAX_ARGS_LEN) {
         throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);
@@ -25,7 +25,7 @@ export function decodeSpi(data, args, preallocateMemoryPages = 0) {
     const codeLength = decoder.u32();
     const code = decoder.bytes(codeLength);
     decoder.finish();
-    const program = deblob(code);
+    const program = deblob(code, useBlockGas);
     // building memory
     const builder = new MemoryBuilder(preallocateMemoryPages);
     const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);