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

package/dist/build/debug.js

@@ -29,46 +29,49 @@ async function instantiate(module, imports = {}) {
     },
     wrapAsProgram(bytecode) {
       // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array
-      bytecode = __lowerTypedArray(Uint8Array, 12, 0, bytecode) || __notnull();
+      bytecode = __lowerTypedArray(Uint8Array, 15, 0, bytecode) || __notnull();
       return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0);
     },
-    resetJAM(program, pc, initialGas, args, hasMetadata) {
-      // assembly/api-debugger/resetJAM(~lib/array/Array<u8>, u32, u64, ~lib/array/Array<u8>, bool?) => void
-      program = __retain(__lowerArray(__setU8, 7, 0, program) || __notnull());
+    resetJAM(program, pc, initialGas, args, hasMetadata, useBlockGas) {
+      // assembly/api-debugger/resetJAM(~lib/array/Array<u8>, u32, u64, ~lib/array/Array<u8>, bool?, bool?) => void
+      program = __retain(__lowerArray(__setU8, 32, 0, program) || __notnull());
       initialGas = initialGas || 0n;
-      args = __lowerArray(__setU8, 7, 0, args) || __notnull();
+      args = __lowerArray(__setU8, 32, 0, args) || __notnull();
       hasMetadata = hasMetadata ? 1 : 0;
+      useBlockGas = useBlockGas ? 1 : 0;
       try {
         exports.__setArgumentsLength(arguments.length);
-        exports.resetJAM(program, pc, initialGas, args, hasMetadata);
+        exports.resetJAM(program, pc, initialGas, args, hasMetadata, useBlockGas);
       } finally {
         __release(program);
       }
     },
-    resetGeneric(program, flatRegisters, initialGas, hasMetadata) {
-      // assembly/api-debugger/resetGeneric(~lib/array/Array<u8>, ~lib/array/Array<u8>, u64, bool?) => void
-      program = __retain(__lowerArray(__setU8, 7, 0, program) || __notnull());
-      flatRegisters = __lowerArray(__setU8, 7, 0, flatRegisters) || __notnull();
+    resetGeneric(program, flatRegisters, initialGas, hasMetadata, useBlockGas) {
+      // assembly/api-debugger/resetGeneric(~lib/array/Array<u8>, ~lib/array/Array<u8>, u64, bool?, bool?) => void
+      program = __retain(__lowerArray(__setU8, 32, 0, program) || __notnull());
+      flatRegisters = __lowerArray(__setU8, 32, 0, flatRegisters) || __notnull();
       initialGas = initialGas || 0n;
       hasMetadata = hasMetadata ? 1 : 0;
+      useBlockGas = useBlockGas ? 1 : 0;
       try {
         exports.__setArgumentsLength(arguments.length);
-        exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata);
+        exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata, useBlockGas);
       } finally {
         __release(program);
       }
     },
-    resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) {
-      // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array<u8>, ~lib/array/Array<u8>, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, u64, bool?) => void
-      program = __retain(__lowerArray(__setU8, 7, 0, program) || __notnull());
-      flatRegisters = __retain(__lowerArray(__setU8, 7, 0, flatRegisters) || __notnull());
-      pageMap = __retain(__lowerTypedArray(Uint8Array, 12, 0, pageMap) || __notnull());
-      chunks = __lowerTypedArray(Uint8Array, 12, 0, chunks) || __notnull();
+    resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata, useBlockGas) {
+      // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array<u8>, ~lib/array/Array<u8>, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, u64, bool?, bool?) => void
+      program = __retain(__lowerArray(__setU8, 32, 0, program) || __notnull());
+      flatRegisters = __retain(__lowerArray(__setU8, 32, 0, flatRegisters) || __notnull());
+      pageMap = __retain(__lowerTypedArray(Uint8Array, 15, 0, pageMap) || __notnull());
+      chunks = __lowerTypedArray(Uint8Array, 15, 0, chunks) || __notnull();
       initialGas = initialGas || 0n;
       hasMetadata = hasMetadata ? 1 : 0;
+      useBlockGas = useBlockGas ? 1 : 0;
       try {
         exports.__setArgumentsLength(arguments.length);
-        exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata);
+        exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata, useBlockGas);
       } finally {
         __release(program);
         __release(flatRegisters);
@@ -102,7 +105,7 @@ async function instantiate(module, imports = {}) {
     },
     setRegisters(flatRegisters) {
       // assembly/api-debugger/setRegisters(~lib/array/Array<u8>) => void
-      flatRegisters = __lowerArray(__setU8, 7, 0, flatRegisters) || __notnull();
+      flatRegisters = __lowerArray(__setU8, 32, 0, flatRegisters) || __notnull();
       exports.setRegisters(flatRegisters);
     },
     getPageDump(index) {
@@ -119,7 +122,7 @@ async function instantiate(module, imports = {}) {
     },
     setMemory(address, data) {
       // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
-      data = __lowerTypedArray(Uint8Array, 12, 0, data) || __notnull();
+      data = __lowerTypedArray(Uint8Array, 15, 0, data) || __notnull();
       return exports.setMemory(address, data) != 0;
     },
     InputKind: (values => (
@@ -134,25 +137,26 @@ async function instantiate(module, imports = {}) {
       values[values.No = exports["HasMetadata.No"].valueOf()] = "No",
       values
     ))({}),
-    getGasCosts(input, kind, withMetadata) {
-      // assembly/api-utils/getGasCosts(~lib/array/Array<u8>, i32, i32) => ~lib/array/Array<assembly/gas-costs/BlockGasCost>
-      input = __lowerArray(__setU8, 7, 0, input) || __notnull();
-      return __liftArray(pointer => __liftRecord54(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0);
+    getBlockGasCosts(input, kind, withMetadata) {
+      // assembly/api-utils/getBlockGasCosts(~lib/array/Array<u8>, i32, i32) => ~lib/array/Array<assembly/api-utils/BlockGasCost>
+      input = __lowerArray(__setU8, 32, 0, input) || __notnull();
+      return __liftArray(pointer => __liftRecord58(__getU32(pointer)), 2, exports.getBlockGasCosts(input, kind, withMetadata) >>> 0);
     },
     disassemble(input, kind, withMetadata) {
       // assembly/api-utils/disassemble(~lib/array/Array<u8>, i32, i32) => ~lib/string/String
-      input = __lowerArray(__setU8, 7, 0, input) || __notnull();
+      input = __lowerArray(__setU8, 32, 0, input) || __notnull();
       return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0);
     },
-    prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages) {
-      // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array<u8>, ~lib/array/Array<u64>, ~lib/array/Array<assembly/api-types/InitialPage>, ~lib/array/Array<assembly/api-types/InitialChunk>, ~lib/array/Array<u8>, u32) => assembly/spi/StandardProgram
-      program = __retain(__lowerArray(__setU8, 7, 0, program) || __notnull());
-      initialRegisters = __retain(__lowerArray(__setU64, 56, 3, initialRegisters) || __notnull());
-      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord50(value) || __notnull()); }, 51, 2, initialPageMap) || __notnull());
-      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord52(value) || __notnull()); }, 53, 2, initialMemory) || __notnull());
-      args = __lowerArray(__setU8, 7, 0, args) || __notnull();
+    prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages, useBlockGas) {
+      // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array<u8>, ~lib/array/Array<u64>, ~lib/array/Array<assembly/api-types/InitialPage>, ~lib/array/Array<assembly/api-types/InitialChunk>, ~lib/array/Array<u8>, u32, bool) => assembly/spi/StandardProgram
+      program = __retain(__lowerArray(__setU8, 32, 0, program) || __notnull());
+      initialRegisters = __retain(__lowerArray(__setU64, 60, 3, initialRegisters) || __notnull());
+      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord54(value) || __notnull()); }, 55, 2, initialPageMap) || __notnull());
+      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord56(value) || __notnull()); }, 57, 2, initialMemory) || __notnull());
+      args = __lowerArray(__setU8, 32, 0, args) || __notnull();
+      useBlockGas = useBlockGas ? 1 : 0;
       try {
-        return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages) >>> 0);
+        return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages, useBlockGas) >>> 0);
       } finally {
         __release(program);
         __release(initialRegisters);
@@ -160,30 +164,27 @@ async function instantiate(module, imports = {}) {
         __release(initialMemory);
       }
     },
-    runProgram(program, initialGas, programCounter, logs, useSbrkGas, dumpMemory) {
-      // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?, bool?) => assembly/api-types/VmOutput
+    runProgram(program, initialGas, programCounter, logs, dumpMemory) {
+      // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-types/VmOutput
       program = __lowerInternref(program) || __notnull();
       initialGas = initialGas || 0n;
       logs = logs ? 1 : 0;
-      useSbrkGas = useSbrkGas ? 1 : 0;
       dumpMemory = dumpMemory ? 1 : 0;
       exports.__setArgumentsLength(arguments.length);
-      return __liftRecord59(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas, dumpMemory) >>> 0);
+      return __liftRecord62(exports.runProgram(program, initialGas, programCounter, logs, dumpMemory) >>> 0);
     },
-    pvmStart(program, useSbrkGas) {
-      // assembly/api-utils/pvmStart(assembly/spi/StandardProgram, bool?) => u32
+    pvmStart(program) {
+      // assembly/api-utils/pvmStart(assembly/spi/StandardProgram) => u32
       program = __lowerInternref(program) || __notnull();
-      useSbrkGas = useSbrkGas ? 1 : 0;
-      exports.__setArgumentsLength(arguments.length);
-      return exports.pvmStart(program, useSbrkGas) >>> 0;
+      return exports.pvmStart(program) >>> 0;
     },
     pvmDestroy(pvmId) {
       // assembly/api-utils/pvmDestroy(u32) => assembly/api-types/VmOutput | null
-      return __liftRecord59(exports.pvmDestroy(pvmId) >>> 0);
+      return __liftRecord62(exports.pvmDestroy(pvmId) >>> 0);
     },
     pvmSetRegisters(pvmId, registers) {
       // assembly/api-utils/pvmSetRegisters(u32, ~lib/array/Array<u64>) => void
-      registers = __lowerArray(__setU64, 56, 3, registers) || __notnull();
+      registers = __lowerArray(__setU64, 60, 3, registers) || __notnull();
       exports.pvmSetRegisters(pvmId, registers);
     },
     pvmReadMemory(pvmId, address, length) {
@@ -196,7 +197,7 @@ async function instantiate(module, imports = {}) {
     },
     pvmWriteMemory(pvmId, address, data) {
       // assembly/api-utils/pvmWriteMemory(u32, u32, ~lib/typedarray/Uint8Array) => bool
-      data = __lowerTypedArray(Uint8Array, 12, 0, data) || __notnull();
+      data = __lowerTypedArray(Uint8Array, 15, 0, data) || __notnull();
       return exports.pvmWriteMemory(pvmId, address, data) != 0;
     },
     pvmResume(pvmId, gas, pc, logs) {
@@ -204,11 +205,11 @@ async function instantiate(module, imports = {}) {
       gas = gas || 0n;
       logs = logs ? 1 : 0;
       exports.__setArgumentsLength(arguments.length);
-      return __liftRecord65(exports.pvmResume(pvmId, gas, pc, logs) >>> 0);
+      return __liftRecord68(exports.pvmResume(pvmId, gas, pc, logs) >>> 0);
     },
   }, exports);
-  function __liftRecord54(pointer) {
-    // assembly/gas-costs/BlockGasCost
+  function __liftRecord58(pointer) {
+    // assembly/api-utils/BlockGasCost
     // Hint: Opt-out from lifting as a record by providing an empty constructor
     if (!pointer) return null;
     return {
@@ -216,28 +217,28 @@ async function instantiate(module, imports = {}) {
       gas: __getU64(pointer + 8),
     };
   }
-  function __lowerRecord50(value) {
+  function __lowerRecord54(value) {
     // assembly/api-types/InitialPage
     // Hint: Opt-out from lowering as a record by providing an empty constructor
     if (value == null) return 0;
-    const pointer = exports.__pin(exports.__new(12, 50));
+    const pointer = exports.__pin(exports.__new(12, 54));
     __setU32(pointer + 0, value.address);
     __setU32(pointer + 4, value.length);
     __setU32(pointer + 8, value.access);
     exports.__unpin(pointer);
     return pointer;
   }
-  function __lowerRecord52(value) {
+  function __lowerRecord56(value) {
     // assembly/api-types/InitialChunk
     // Hint: Opt-out from lowering as a record by providing an empty constructor
     if (value == null) return 0;
-    const pointer = exports.__pin(exports.__new(8, 52));
+    const pointer = exports.__pin(exports.__new(8, 56));
     __setU32(pointer + 0, value.address);
-    __setU32(pointer + 4, __lowerArray(__setU8, 7, 0, value.data) || __notnull());
+    __setU32(pointer + 4, __lowerArray(__setU8, 32, 0, value.data) || __notnull());
     exports.__unpin(pointer);
     return pointer;
   }
-  function __liftRecord52(pointer) {
+  function __liftRecord56(pointer) {
     // assembly/api-types/InitialChunk
     // Hint: Opt-out from lifting as a record by providing an empty constructor
     if (!pointer) return null;
@@ -246,7 +247,7 @@ async function instantiate(module, imports = {}) {
       data: __liftArray(__getU8, 0, __getU32(pointer + 4)),
     };
   }
-  function __liftRecord59(pointer) {
+  function __liftRecord62(pointer) {
     // assembly/api-types/VmOutput
     // Hint: Opt-out from lifting as a record by providing an empty constructor
     if (!pointer) return null;
@@ -257,10 +258,10 @@ async function instantiate(module, imports = {}) {
       gas: __getU64(pointer + 16),
       result: __liftArray(__getU8, 0, __getU32(pointer + 24)),
       registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 28)),
-      memory: __liftArray(pointer => __liftRecord52(__getU32(pointer)), 2, __getU32(pointer + 32)),
+      memory: __liftArray(pointer => __liftRecord56(__getU32(pointer)), 2, __getU32(pointer + 32)),
     };
   }
-  function __liftRecord65(pointer) {
+  function __liftRecord68(pointer) {
     // assembly/api-types/VmPause
     // Hint: Opt-out from lifting as a record by providing an empty constructor
     if (!pointer) return null;
@@ -444,7 +445,7 @@ export const {
   setMemory,
   InputKind,
   HasMetadata,
-  getGasCosts,
+  getBlockGasCosts,
   disassemble,
   prepareProgram,
   runProgram,

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

@@ -1,7 +1,7 @@
 import { Gas } from "./gas";
-export declare function resetJAM(program: u8[], pc: u32, initialGas: Gas, args: u8[], hasMetadata?: boolean): void;
-export declare function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata?: boolean): void;
-export declare function resetGenericWithMemory(program: u8[], flatRegisters: u8[], pageMap: Uint8Array, chunks: Uint8Array, initialGas: Gas, hasMetadata?: boolean): void;
+export declare function resetJAM(program: u8[], pc: u32, initialGas: Gas, args: u8[], hasMetadata?: boolean, useBlockGas?: boolean): void;
+export declare function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata?: boolean, useBlockGas?: boolean): void;
+export declare function resetGenericWithMemory(program: u8[], flatRegisters: u8[], pageMap: Uint8Array, chunks: Uint8Array, initialGas: Gas, hasMetadata?: boolean, useBlockGas?: boolean): void;
 export declare function nextStep(): boolean;
 export declare function nSteps(steps: u32): boolean;
 export declare function getProgramCounter(): u32;

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

@@ -8,9 +8,9 @@ import { deblob, extractCodeAndMetadata, liftBytes } from "./program";
 import { NO_OF_REGISTERS, newRegisters, REG_SIZE_BYTES } from "./registers";
 import { decodeSpi } from "./spi";
 let interpreter = null;
-export function resetJAM(program, pc, initialGas, args, hasMetadata = false) {
+export function resetJAM(program, pc, initialGas, args, hasMetadata = false, useBlockGas = false) {
     const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-    const p = decodeSpi(code, liftBytes(args), 128);
+    const p = decodeSpi(code, liftBytes(args), 128, useBlockGas);
     const int = new Interpreter(p.program, p.registers, p.memory);
     int.nextPc = pc;
     int.gas.set(initialGas);
@@ -19,9 +19,9 @@ export function resetJAM(program, pc, initialGas, args, hasMetadata = false) {
     }
     interpreter = int;
 }
-export function resetGeneric(program, flatRegisters, initialGas, hasMetadata = false) {
+export function resetGeneric(program, flatRegisters, initialGas, hasMetadata = false, useBlockGas = false) {
     const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-    const p = deblob(code);
+    const p = deblob(code, useBlockGas);
     const registers = newRegisters();
     fillRegisters(registers, flatRegisters);
     const int = new Interpreter(p, registers);
@@ -31,9 +31,9 @@ export function resetGeneric(program, flatRegisters, initialGas, hasMetadata = f
     }
     interpreter = int;
 }
-export function resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata = false) {
+export function resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata = false, useBlockGas = false) {
     const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-    const p = deblob(code);
+    const p = deblob(code, useBlockGas);
     const registers = newRegisters();
     fillRegisters(registers, flatRegisters);
     const builder = new MemoryBuilder();

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

@@ -5,7 +5,7 @@ import { Program } from "./program";
 export declare function getAssembly(p: Program): string;
 export declare function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory;
 /** Initialize new VM for execution. */
-export declare function vmInit(input: VmInput, useSbrkGas?: boolean): Interpreter;
+export declare function vmInit(input: VmInput): Interpreter;
 /** Initialize & run & destroy a VM in a single go. */
 export declare function vmRunOnce(input: VmInput, options: VmRunOptions): VmOutput;
 export declare function vmExecute(int: Interpreter, logs?: boolean): void;

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

@@ -60,16 +60,15 @@ export function buildMemory(builder, pages, chunks) {
     return builder.build(sbrkIndex);
 }
 /** Initialize new VM for execution. */
-export function vmInit(input, useSbrkGas = false) {
+export function vmInit(input) {
     const int = new Interpreter(input.program, input.registers, input.memory);
-    int.useSbrkGas = useSbrkGas;
     int.nextPc = input.pc;
     int.gas.set(input.gas);
     return int;
 }
 /** Initialize & run & destroy a VM in a single go. */
 export function vmRunOnce(input, options) {
-    const int = vmInit(input, options.useSbrkGas);
+    const int = vmInit(input);
     vmExecute(int, options.logs);
     return vmDestroy(int, options.dumpMemory);
 }

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

@@ -15,7 +15,6 @@ export declare class InitialChunk {
     data: u8[];
 }
 export declare class VmRunOptions {
-    useSbrkGas: boolean;
     logs: boolean;
     dumpMemory: boolean;
 }

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

@@ -16,7 +16,6 @@ export class InitialChunk {
 }
 export class VmRunOptions {
     constructor() {
-        this.useSbrkGas = false;
         this.logs = false;
         this.dumpMemory = false;
     }

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

@@ -1,6 +1,6 @@
 import { InitialChunk, InitialPage, VmOutput, VmPause } from "./api-types";
 import { Gas } from "./gas";
-import { BlockGasCost } from "./gas-costs";
+import { ProgramCounter } from "./program";
 import { StandardProgram } from "./spi";
 export declare enum InputKind {
     Generic = 0,
@@ -10,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. */
@@ -22,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. */
@@ -70,3 +76,4 @@ export declare function pvmGetPagePointer(pvmId: u32, page: u32): usize;
 export declare function pvmWriteMemory(pvmId: u32, address: u32, data: Uint8Array): boolean;
 /** Resume execution of paused VM. */
 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

@@ -7,5 +7,5 @@ export declare class GasCounter {
     constructor(gas: Gas);
     set(g: Gas): void;
     get(): Gas;
-    sub(g: Gas): boolean;
+    sub(g: u32): boolean;
 }

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

@@ -19,11 +19,12 @@ export class GasCounter {
         return this.gas;
     }
     sub(g) {
-        if (g > this.gas) {
+        const cost = u64(g);
+        if (cost > this.gas) {
             this.gas = u64(0);
             return true;
         }
-        this.gas = this.gas - g;
+        this.gas = this.gas - cost;
         return false;
     }
 }