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

package/dist/build/debug.d.ts

@@ -5,7 +5,7 @@ export declare const memory: WebAssembly.Memory;
  * @param p `assembly/program/Program`
  * @returns `~lib/string/String`
  */
-export declare function getAssembly(p: __Internref28): string;
+export declare function getAssembly(p: __Internref35): string;
 /**
  * assembly/program-build/wrapAsProgram
  * @param bytecode `~lib/typedarray/Uint8Array`
@@ -16,29 +16,32 @@ export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array;
  * assembly/api-debugger/resetJAM
  * @param program `~lib/array/Array<u8>`
  * @param pc `u32`
- * @param initialGas `i64`
+ * @param initialGas `u64`
  * @param args `~lib/array/Array<u8>`
  * @param hasMetadata `bool`
+ * @param useBlockGas `bool`
  */
-export declare function resetJAM(program: Array<number>, pc: number, initialGas: bigint, args: Array<number>, hasMetadata?: boolean): void;
+export declare function resetJAM(program: Array<number>, pc: number, initialGas: bigint, args: Array<number>, hasMetadata?: boolean, useBlockGas?: boolean): void;
 /**
  * assembly/api-debugger/resetGeneric
  * @param program `~lib/array/Array<u8>`
  * @param flatRegisters `~lib/array/Array<u8>`
- * @param initialGas `i64`
+ * @param initialGas `u64`
  * @param hasMetadata `bool`
+ * @param useBlockGas `bool`
  */
-export declare function resetGeneric(program: Array<number>, flatRegisters: Array<number>, initialGas: bigint, hasMetadata?: boolean): void;
+export declare function resetGeneric(program: Array<number>, flatRegisters: Array<number>, initialGas: bigint, hasMetadata?: boolean, useBlockGas?: boolean): void;
 /**
  * assembly/api-debugger/resetGenericWithMemory
  * @param program `~lib/array/Array<u8>`
  * @param flatRegisters `~lib/array/Array<u8>`
  * @param pageMap `~lib/typedarray/Uint8Array`
  * @param chunks `~lib/typedarray/Uint8Array`
- * @param initialGas `i64`
+ * @param initialGas `u64`
  * @param hasMetadata `bool`
+ * @param useBlockGas `bool`
  */
-export declare function resetGenericWithMemory(program: Array<number>, flatRegisters: Array<number>, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void;
+export declare function resetGenericWithMemory(program: Array<number>, flatRegisters: Array<number>, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean, useBlockGas?: boolean): void;
 /**
  * assembly/api-debugger/nextStep
  * @returns `bool`
@@ -77,7 +80,7 @@ export declare function getExitArg(): number;
 export declare function getGasLeft(): bigint;
 /**
  * assembly/api-debugger/setGasLeft
- * @param gas `i64`
+ * @param gas `u64`
  */
 export declare function setGasLeft(gas: bigint): void;
 /**
@@ -131,13 +134,13 @@ export declare enum HasMetadata {
   No,
 }
 /**
- * assembly/api-utils/getGasCosts
+ * assembly/api-utils/getBlockGasCosts
  * @param input `~lib/array/Array<u8>`
  * @param kind `i32`
  * @param withMetadata `i32`
- * @returns `~lib/array/Array<assembly/gas-costs/BlockGasCost>`
+ * @returns `~lib/array/Array<assembly/api-utils/BlockGasCost>`
  */
-export declare function getGasCosts(input: Array<number>, kind: number, withMetadata: number): Array<__Record53<never>>;
+export declare function getBlockGasCosts(input: Array<number>, kind: number, withMetadata: number): Array<__Record58<never>>;
 /**
  * assembly/api-utils/disassemble
  * @param input `~lib/array/Array<u8>`
@@ -156,33 +159,32 @@ export declare function disassemble(input: Array<number>, kind: number, withMeta
  * @param initialMemory `~lib/array/Array<assembly/api-types/InitialChunk>`
  * @param args `~lib/array/Array<u8>`
  * @param preallocateMemoryPages `u32`
+ * @param useBlockGas `bool`
  * @returns `assembly/spi/StandardProgram`
  */
-export declare function prepareProgram(kind: number, hasMetadata: number, program: Array<number>, initialRegisters: Array<bigint>, initialPageMap: Array<__Record49<undefined>>, initialMemory: Array<__Record51<undefined>>, args: Array<number>, preallocateMemoryPages: number): __Internref45;
+export declare function prepareProgram(kind: number, hasMetadata: number, program: Array<number>, initialRegisters: Array<bigint>, initialPageMap: Array<__Record54<undefined>>, initialMemory: Array<__Record56<undefined>>, args: Array<number>, preallocateMemoryPages: number, useBlockGas: boolean): __Internref51;
 /**
  * assembly/api-utils/runProgram
  * @param program `assembly/spi/StandardProgram`
  * @param initialGas `i64`
  * @param programCounter `u32`
  * @param logs `bool`
- * @param useSbrkGas `bool`
  * @param dumpMemory `bool`
  * @returns `assembly/api-types/VmOutput`
  */
-export declare function runProgram(program: __Internref45, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean, dumpMemory?: boolean): __Record58<never>;
+export declare function runProgram(program: __Internref51, initialGas?: bigint, programCounter?: number, logs?: boolean, dumpMemory?: boolean): __Record62<never>;
 /**
  * assembly/api-utils/pvmStart
  * @param program `assembly/spi/StandardProgram`
- * @param useSbrkGas `bool`
  * @returns `u32`
  */
-export declare function pvmStart(program: __Internref45, useSbrkGas?: boolean): number;
+export declare function pvmStart(program: __Internref51): number;
 /**
  * assembly/api-utils/pvmDestroy
  * @param pvmId `u32`
  * @returns `assembly/api-types/VmOutput | null`
  */
-export declare function pvmDestroy(pvmId: number): __Record58<never> | null;
+export declare function pvmDestroy(pvmId: number): __Record62<never> | null;
 /**
  * assembly/api-utils/pvmSetRegisters
  * @param pvmId `u32`
@@ -215,26 +217,26 @@ export declare function pvmWriteMemory(pvmId: number, address: number, data: Uin
 /**
  * assembly/api-utils/pvmResume
  * @param pvmId `u32`
- * @param gas `i64`
+ * @param gas `u64`
  * @param pc `u32`
  * @param logs `bool`
  * @returns `assembly/api-types/VmPause | null`
  */
-export declare function pvmResume(pvmId: number, gas: bigint, pc: number, logs?: boolean): __Record64<never> | null;
+export declare function pvmResume(pvmId: number, gas: bigint, pc: number, logs?: boolean): __Record68<never> | null;
 /** assembly/program/Program */
-declare class __Internref28 extends Number {
-  private __nominal28: symbol;
+declare class __Internref35 extends Number {
+  private __nominal35: symbol;
   private __nominal0: symbol;
 }
-/** assembly/gas-costs/BlockGasCost */
-declare interface __Record53<TOmittable> {
+/** assembly/api-utils/BlockGasCost */
+declare interface __Record58<TOmittable> {
   /** @type `u32` */
   pc: number | TOmittable;
   /** @type `u64` */
   gas: bigint | TOmittable;
 }
 /** assembly/api-types/InitialPage */
-declare interface __Record49<TOmittable> {
+declare interface __Record54<TOmittable> {
   /** @type `u32` */
   address: number | TOmittable;
   /** @type `u32` */
@@ -243,36 +245,36 @@ declare interface __Record49<TOmittable> {
   access: number | TOmittable;
 }
 /** assembly/api-types/InitialChunk */
-declare interface __Record51<TOmittable> {
+declare interface __Record56<TOmittable> {
   /** @type `u32` */
   address: number | TOmittable;
   /** @type `~lib/array/Array<u8>` */
   data: Array<number>;
 }
 /** assembly/spi/StandardProgram */
-declare class __Internref45 extends Number {
-  private __nominal45: symbol;
+declare class __Internref51 extends Number {
+  private __nominal51: symbol;
   private __nominal0: symbol;
 }
 /** assembly/api-types/VmOutput */
-declare interface __Record58<TOmittable> {
+declare interface __Record62<TOmittable> {
   /** @type `i32` */
   status: number | TOmittable;
   /** @type `u32` */
   exitCode: number | TOmittable;
   /** @type `u32` */
   pc: number | TOmittable;
-  /** @type `i64` */
+  /** @type `u64` */
   gas: bigint | TOmittable;
   /** @type `~lib/array/Array<u8>` */
   result: Array<number>;
   /** @type `~lib/array/Array<u64>` */
   registers: Array<bigint>;
   /** @type `~lib/array/Array<assembly/api-types/InitialChunk>` */
-  memory: Array<__Record51<never>>;
+  memory: Array<__Record56<never>>;
 }
 /** assembly/api-types/VmPause */
-declare interface __Record64<TOmittable> {
+declare interface __Record68<TOmittable> {
   /** @type `i32` */
   status: number | TOmittable;
   /** @type `u32` */
@@ -281,7 +283,7 @@ declare interface __Record64<TOmittable> {
   pc: number | TOmittable;
   /** @type `u32` */
   nextPc: number | TOmittable;
-  /** @type `i64` */
+  /** @type `u64` */
   gas: bigint | TOmittable;
   /** @type `~lib/array/Array<u64>` */
   registers: Array<bigint>;

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, i64, ~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>, i64, 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, i64, 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);
@@ -92,7 +95,7 @@ async function instantiate(module, imports = {}) {
       return exports.getExitArg() >>> 0;
     },
     setGasLeft(gas) {
-      // assembly/api-debugger/setGasLeft(i64) => void
+      // assembly/api-debugger/setGasLeft(u64) => void
       gas = gas || 0n;
       exports.setGasLeft(gas);
     },
@@ -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 => __liftRecord53(__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, 55, 3, initialRegisters) || __notnull());
-      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord49(value) || __notnull()); }, 50, 2, initialPageMap) || __notnull());
-      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord51(value) || __notnull()); }, 52, 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 __liftRecord58(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 __liftRecord58(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, 55, 3, registers) || __notnull();
+      registers = __lowerArray(__setU64, 60, 3, registers) || __notnull();
       exports.pvmSetRegisters(pvmId, registers);
     },
     pvmReadMemory(pvmId, address, length) {
@@ -196,19 +197,19 @@ 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) {
-      // assembly/api-utils/pvmResume(u32, i64, u32, bool?) => assembly/api-types/VmPause | null
+      // assembly/api-utils/pvmResume(u32, u64, u32, bool?) => assembly/api-types/VmPause | null
       gas = gas || 0n;
       logs = logs ? 1 : 0;
       exports.__setArgumentsLength(arguments.length);
-      return __liftRecord64(exports.pvmResume(pvmId, gas, pc, logs) >>> 0);
+      return __liftRecord68(exports.pvmResume(pvmId, gas, pc, logs) >>> 0);
     },
   }, exports);
-  function __liftRecord53(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 __lowerRecord49(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, 49));
+    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 __lowerRecord51(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, 51));
+    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 __liftRecord51(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 __liftRecord58(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;
@@ -254,13 +255,13 @@ async function instantiate(module, imports = {}) {
       status: __getI32(pointer + 0),
       exitCode: __getU32(pointer + 4),
       pc: __getU32(pointer + 8),
-      gas: __getI64(pointer + 16),
+      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 => __liftRecord51(__getU32(pointer)), 2, __getU32(pointer + 32)),
+      memory: __liftArray(pointer => __liftRecord56(__getU32(pointer)), 2, __getU32(pointer + 32)),
     };
   }
-  function __liftRecord64(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;
@@ -269,7 +270,7 @@ async function instantiate(module, imports = {}) {
       exitCode: __getU32(pointer + 4),
       pc: __getU32(pointer + 8),
       nextPc: __getU32(pointer + 12),
-      gas: __getI64(pointer + 16),
+      gas: __getU64(pointer + 16),
       registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 24)),
     };
   }
@@ -411,14 +412,6 @@ async function instantiate(module, imports = {}) {
       return __dataview.getUint32(pointer, true);
     }
   }
-  function __getI64(pointer) {
-    try {
-      return __dataview.getBigInt64(pointer, true);
-    } catch {
-      __dataview = new DataView(memory.buffer);
-      return __dataview.getBigInt64(pointer, true);
-    }
-  }
   function __getU64(pointer) {
     try {
       return __dataview.getBigUint64(pointer, true);
@@ -452,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;
@@ -9,7 +9,7 @@ export declare function setNextProgramCounter(pc: u32): void;
 export declare function getStatus(): u8;
 export declare function getExitArg(): u32;
 export declare function getGasLeft(): i64;
-export declare function setGasLeft(gas: i64): void;
+export declare function setGasLeft(gas: Gas): void;
 export declare function getRegisters(): Uint8Array;
 export declare function setRegisters(flatRegisters: u8[]): void;
 export declare function getPageDump(index: u32): Uint8Array;

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

@@ -1,4 +1,5 @@
 /** We split out type definitions, because they can't be exported from WASM. */
+import { Gas } from "./gas";
 import { Status } from "./interpreter";
 import { Memory } from "./memory";
 import { Access } from "./memory-page";
@@ -14,7 +15,6 @@ export declare class InitialChunk {
     data: u8[];
 }
 export declare class VmRunOptions {
-    useSbrkGas: boolean;
     logs: boolean;
     dumpMemory: boolean;
 }
@@ -23,7 +23,7 @@ export declare class VmInput {
     readonly memory: Memory;
     readonly registers: Registers;
     pc: u32;
-    gas: i64;
+    gas: Gas;
     constructor(program: Program, memory: Memory, registers: Registers);
 }
 export declare class VmPause {
@@ -31,14 +31,14 @@ export declare class VmPause {
     exitCode: u32;
     pc: u32;
     nextPc: u32;
-    gas: i64;
+    gas: Gas;
     registers: u64[];
 }
 export declare class VmOutput {
     status: Status;
     exitCode: u32;
     pc: u32;
-    gas: i64;
+    gas: Gas;
     result: u8[];
     registers: u64[];
     memory: InitialChunk[];

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;
     }
@@ -27,7 +26,7 @@ export class VmInput {
         this.memory = memory;
         this.registers = registers;
         this.pc = 0;
-        this.gas = i64(0);
+        this.gas = u64(0);
     }
 }
 export class VmPause {
@@ -36,7 +35,7 @@ export class VmPause {
         this.exitCode = 0;
         this.pc = 0;
         this.nextPc = 0;
-        this.gas = i64(0);
+        this.gas = u64(0);
         this.registers = [];
     }
 }
@@ -45,7 +44,7 @@ export class VmOutput {
         this.status = Status.OK;
         this.exitCode = 0;
         this.pc = 0;
-        this.gas = i64(0);
+        this.gas = u64(0);
         this.result = [];
         this.registers = [];
         this.memory = [];