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

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,26 +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 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 extended = new Array(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[i - offset] = code[i];
+            EXTENDED_BUF[i - offset] = unchecked(code[i]);
         }
-        return DECODERS[kind](args, extended, 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() {
@@ -226,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);

package/dist/build/js/portable/bootstrap.js

@@ -1,3 +1,4 @@
+"use strict";
 // Portable bootstrap for globals that must exist before assembly/portable executes.
 const g = globalThis;
 if (g.ASC_TARGET === undefined) {