@aztec/simulator 0.55.1 → 0.57.0

package/src/avm/avm_gas.ts

@@ -53,10 +53,10 @@ function makeCost(l2Gas: number, daGas: number): Gas {
 }
 
 /** Dimensions of gas usage: L1, L2, and DA. */
-export const GasDimensions = ['l2Gas', 'daGas'] as const;
+export const GAS_DIMENSIONS = ['l2Gas', 'daGas'] as const;
 
 /** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */
-const BaseGasCosts: Record<Opcode, Gas> = {
+const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.ADD_8]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
   [Opcode.ADD_16]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
   [Opcode.SUB_8]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
@@ -87,20 +87,8 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.SHR_16]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
   [Opcode.CAST_8]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
   [Opcode.CAST_16]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
-  [Opcode.ADDRESS]: makeCost(c.AVM_ADDRESS_BASE_L2_GAS, 0),
-  [Opcode.STORAGEADDRESS]: makeCost(c.AVM_STORAGEADDRESS_BASE_L2_GAS, 0),
-  [Opcode.SENDER]: makeCost(c.AVM_SENDER_BASE_L2_GAS, 0),
-  [Opcode.FEEPERL2GAS]: makeCost(c.AVM_FEEPERL2GAS_BASE_L2_GAS, 0),
-  [Opcode.FEEPERDAGAS]: makeCost(c.AVM_FEEPERDAGAS_BASE_L2_GAS, 0),
-  [Opcode.TRANSACTIONFEE]: makeCost(c.AVM_TRANSACTIONFEE_BASE_L2_GAS, 0),
-  [Opcode.FUNCTIONSELECTOR]: makeCost(c.AVM_FUNCTIONSELECTOR_BASE_L2_GAS, 0),
-  [Opcode.CHAINID]: makeCost(c.AVM_CHAINID_BASE_L2_GAS, 0),
-  [Opcode.VERSION]: makeCost(c.AVM_VERSION_BASE_L2_GAS, 0),
-  [Opcode.BLOCKNUMBER]: makeCost(c.AVM_BLOCKNUMBER_BASE_L2_GAS, 0),
-  [Opcode.TIMESTAMP]: makeCost(c.AVM_TIMESTAMP_BASE_L2_GAS, 0),
+  [Opcode.GETENVVAR_16]: makeCost(c.AVM_GETENVVAR_BASE_L2_GAS, 0),
   [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_BASE_L2_GAS, 0),
-  [Opcode.L2GASLEFT]: makeCost(c.AVM_L2GASLEFT_BASE_L2_GAS, 0),
-  [Opcode.DAGASLEFT]: makeCost(c.AVM_DAGASLEFT_BASE_L2_GAS, 0),
   [Opcode.JUMP_16]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
   [Opcode.JUMPI_16]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
   [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_BASE_L2_GAS, 0),
@@ -113,16 +101,15 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.SET_FF]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
   [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
-  [Opcode.CMOV]: makeCost(c.AVM_CMOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
-  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, 0),
+  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
   [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
-  [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, 0),
+  [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, c.AVM_EMITNOTEHASH_BASE_DA_GAS),
   [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
-  [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, 0),
+  [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, c.AVM_EMITNULLIFIER_BASE_DA_GAS),
   [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, 0),
-  [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, 0),
+  [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, c.AVM_SENDL2TOL1MSG_BASE_DA_GAS),
   [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_BASE_L2_GAS, 0),
   [Opcode.CALL]: makeCost(c.AVM_CALL_BASE_L2_GAS, 0),
   [Opcode.STATICCALL]: makeCost(c.AVM_STATICCALL_BASE_L2_GAS, 0),
@@ -133,110 +120,37 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.DEBUGLOG]: makeCost(c.AVM_DEBUGLOG_BASE_L2_GAS, 0),
   [Opcode.KECCAK]: makeCost(c.AVM_KECCAK_BASE_L2_GAS, 0),
   [Opcode.POSEIDON2]: makeCost(c.AVM_POSEIDON2_BASE_L2_GAS, 0),
-  [Opcode.SHA256]: makeCost(c.AVM_SHA256_BASE_L2_GAS, 0),
+  [Opcode.SHA256COMPRESSION]: makeCost(c.AVM_SHA256COMPRESSION_BASE_L2_GAS, 0),
+  [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_BASE_L2_GAS, 0),
   [Opcode.PEDERSEN]: makeCost(c.AVM_PEDERSEN_BASE_L2_GAS, 0),
   [Opcode.ECADD]: makeCost(c.AVM_ECADD_BASE_L2_GAS, 0),
   [Opcode.MSM]: makeCost(c.AVM_MSM_BASE_L2_GAS, 0),
   [Opcode.PEDERSENCOMMITMENT]: makeCost(c.AVM_PEDERSENCOMMITMENT_BASE_L2_GAS, 0),
   [Opcode.TORADIXLE]: makeCost(c.AVM_TORADIXLE_BASE_L2_GAS, 0),
-  [Opcode.SHA256COMPRESSION]: makeCost(c.AVM_SHA256COMPRESSION_BASE_L2_GAS, 0),
-  [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_BASE_L2_GAS, 0),
 };
 
-const DynamicGasCosts: Record<Opcode, Gas> = {
-  [Opcode.ADD_8]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
-  [Opcode.ADD_16]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
-  [Opcode.SUB_8]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
-  [Opcode.SUB_16]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
-  [Opcode.MUL_8]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
-  [Opcode.MUL_16]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
-  [Opcode.DIV_8]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
-  [Opcode.DIV_16]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
-  [Opcode.FDIV_8]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
-  [Opcode.FDIV_16]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
-  [Opcode.EQ_8]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
-  [Opcode.EQ_16]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
-  [Opcode.LT_8]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
-  [Opcode.LT_16]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
-  [Opcode.LTE_8]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
-  [Opcode.LTE_16]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
-  [Opcode.AND_8]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
-  [Opcode.AND_16]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
-  [Opcode.OR_8]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
-  [Opcode.OR_16]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
-  [Opcode.XOR_8]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
-  [Opcode.XOR_16]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
-  [Opcode.NOT_8]: makeCost(c.AVM_NOT_DYN_L2_GAS, 0),
-  [Opcode.NOT_16]: makeCost(c.AVM_NOT_DYN_L2_GAS, 0),
-  [Opcode.SHL_8]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
-  [Opcode.SHL_16]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
-  [Opcode.SHR_8]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
-  [Opcode.SHR_16]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
-  [Opcode.CAST_8]: makeCost(c.AVM_CAST_DYN_L2_GAS, 0),
-  [Opcode.CAST_16]: makeCost(c.AVM_CAST_DYN_L2_GAS, 0),
-  [Opcode.ADDRESS]: makeCost(c.AVM_ADDRESS_DYN_L2_GAS, 0),
-  [Opcode.STORAGEADDRESS]: makeCost(c.AVM_STORAGEADDRESS_DYN_L2_GAS, 0),
-  [Opcode.SENDER]: makeCost(c.AVM_SENDER_DYN_L2_GAS, 0),
-  [Opcode.FEEPERL2GAS]: makeCost(c.AVM_FEEPERL2GAS_DYN_L2_GAS, 0),
-  [Opcode.FEEPERDAGAS]: makeCost(c.AVM_FEEPERDAGAS_DYN_L2_GAS, 0),
-  [Opcode.TRANSACTIONFEE]: makeCost(c.AVM_TRANSACTIONFEE_DYN_L2_GAS, 0),
-  [Opcode.FUNCTIONSELECTOR]: makeCost(c.AVM_FUNCTIONSELECTOR_DYN_L2_GAS, 0),
-  [Opcode.CHAINID]: makeCost(c.AVM_CHAINID_DYN_L2_GAS, 0),
-  [Opcode.VERSION]: makeCost(c.AVM_VERSION_DYN_L2_GAS, 0),
-  [Opcode.BLOCKNUMBER]: makeCost(c.AVM_BLOCKNUMBER_DYN_L2_GAS, 0),
-  [Opcode.TIMESTAMP]: makeCost(c.AVM_TIMESTAMP_DYN_L2_GAS, 0),
-  [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0),
-  [Opcode.L2GASLEFT]: makeCost(c.AVM_L2GASLEFT_DYN_L2_GAS, 0),
-  [Opcode.DAGASLEFT]: makeCost(c.AVM_DAGASLEFT_DYN_L2_GAS, 0),
-  [Opcode.JUMP_16]: makeCost(c.AVM_JUMP_DYN_L2_GAS, 0),
-  [Opcode.JUMPI_16]: makeCost(c.AVM_JUMPI_DYN_L2_GAS, 0),
-  [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_DYN_L2_GAS, 0),
-  [Opcode.INTERNALRETURN]: makeCost(c.AVM_INTERNALRETURN_DYN_L2_GAS, 0),
-  [Opcode.SET_8]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.SET_16]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.SET_32]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.SET_64]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.SET_128]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.SET_FF]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
-  [Opcode.MOV_8]: makeCost(c.AVM_MOV_DYN_L2_GAS, 0),
-  [Opcode.MOV_16]: makeCost(c.AVM_MOV_DYN_L2_GAS, 0),
-  [Opcode.CMOV]: makeCost(c.AVM_CMOV_DYN_L2_GAS, 0),
-  [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_DYN_L2_GAS, 0),
-  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_DYN_L2_GAS, 0),
-  [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_DYN_L2_GAS, 0),
-  [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_DYN_L2_GAS, 0),
-  [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_DYN_L2_GAS, 0),
-  [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_DYN_L2_GAS, 0),
-  [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_DYN_L2_GAS, 0),
-  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, 0),
-  [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_DYN_L2_GAS, 0),
-  [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_DYN_L2_GAS, 0),
-  [Opcode.CALL]: makeCost(c.AVM_CALL_DYN_L2_GAS, 0),
-  [Opcode.STATICCALL]: makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0),
-  [Opcode.DELEGATECALL]: makeCost(c.AVM_DELEGATECALL_DYN_L2_GAS, 0),
-  [Opcode.RETURN]: makeCost(c.AVM_RETURN_DYN_L2_GAS, 0),
-  [Opcode.REVERT_8]: makeCost(c.AVM_REVERT_DYN_L2_GAS, 0),
-  [Opcode.REVERT_16]: makeCost(c.AVM_REVERT_DYN_L2_GAS, 0),
-  [Opcode.DEBUGLOG]: makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0),
-  [Opcode.KECCAK]: makeCost(c.AVM_KECCAK_DYN_L2_GAS, 0),
-  [Opcode.POSEIDON2]: makeCost(c.AVM_POSEIDON2_DYN_L2_GAS, 0),
-  [Opcode.SHA256]: makeCost(c.AVM_SHA256_DYN_L2_GAS, 0),
-  [Opcode.PEDERSEN]: makeCost(c.AVM_PEDERSEN_DYN_L2_GAS, 0),
-  [Opcode.ECADD]: makeCost(c.AVM_ECADD_DYN_L2_GAS, 0),
-  [Opcode.MSM]: makeCost(c.AVM_MSM_DYN_L2_GAS, 0),
-  [Opcode.PEDERSENCOMMITMENT]: makeCost(c.AVM_PEDERSENCOMMITMENT_DYN_L2_GAS, 0),
-  [Opcode.TORADIXLE]: makeCost(c.AVM_TORADIXLE_DYN_L2_GAS, 0),
-  [Opcode.SHA256COMPRESSION]: makeCost(c.AVM_SHA256COMPRESSION_DYN_L2_GAS, 0),
-  [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_DYN_L2_GAS, 0),
-};
+const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
+  [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
+  [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
+  [Opcode.CALL, makeCost(c.AVM_CALL_DYN_L2_GAS, 0)],
+  [Opcode.STATICCALL, makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)],
+  [Opcode.DELEGATECALL, makeCost(c.AVM_DELEGATECALL_DYN_L2_GAS, 0)],
+  [Opcode.RETURN, makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)],
+  [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
+  [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
+  [Opcode.PEDERSEN, makeCost(c.AVM_PEDERSEN_DYN_L2_GAS, 0)],
+  [Opcode.MSM, makeCost(c.AVM_MSM_DYN_L2_GAS, 0)],
+  [Opcode.PEDERSENCOMMITMENT, makeCost(c.AVM_PEDERSENCOMMITMENT_DYN_L2_GAS, 0)],
+  [Opcode.TORADIXLE, makeCost(c.AVM_TORADIXLE_DYN_L2_GAS, 0)],
+]);
 
 /** Returns the fixed base gas cost for a given opcode. */
 export function getBaseGasCost(opcode: Opcode): Gas {
-  return BaseGasCosts[opcode];
+  return BASE_GAS_COSTS[opcode];
 }
 
 export function getDynamicGasCost(opcode: Opcode): Gas {
-  return DynamicGasCosts[opcode];
+  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
 /** Returns the gas cost associated with the memory operations performed. */
@@ -244,14 +158,14 @@ export function getMemoryGasCost(args: { reads?: number; writes?: number; indire
   const { reads, writes, indirect } = args;
   const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
   const l2MemoryGasCost =
-    (reads ?? 0) * GasCostConstants.MEMORY_READ +
-    (writes ?? 0) * GasCostConstants.MEMORY_WRITE +
-    indirectCount * GasCostConstants.MEMORY_INDIRECT_READ_PENALTY;
+    (reads ?? 0) * GAS_COST_CONSTANTS.MEMORY_READ +
+    (writes ?? 0) * GAS_COST_CONSTANTS.MEMORY_WRITE +
+    indirectCount * GAS_COST_CONSTANTS.MEMORY_INDIRECT_READ_PENALTY;
   return makeGas({ l2Gas: l2MemoryGasCost });
 }
 
 /** Constants used in base cost calculations. */
-export const GasCostConstants = {
+export const GAS_COST_CONSTANTS = {
   MEMORY_READ: 10,
   MEMORY_INDIRECT_READ_PENALTY: 10,
   MEMORY_WRITE: 100,
@@ -265,6 +179,7 @@ export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
 /** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
 function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
   switch (tag) {
+    case TypeTag.UINT1: // same as u8
     case TypeTag.UINT8:
       return 1;
     case TypeTag.UINT16:

package/src/avm/avm_machine_state.ts

@@ -1,6 +1,6 @@
 import { type Fr } from '@aztec/circuits.js';
 
-import { type Gas, GasDimensions } from './avm_gas.js';
+import { GAS_DIMENSIONS, type Gas } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { OutOfGasError } from './errors.js';
 
@@ -67,7 +67,7 @@ export class AvmMachineState {
    */
   public consumeGas(gasCost: Partial<Gas>) {
     // Assert there is enough gas on every dimension.
-    const outOfGasDimensions = GasDimensions.filter(
+    const outOfGasDimensions = GAS_DIMENSIONS.filter(
       dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
     );
     // If not, trigger an exceptional halt.
@@ -77,14 +77,14 @@ export class AvmMachineState {
       throw new OutOfGasError(outOfGasDimensions);
     }
     // Otherwise, charge the corresponding gas
-    for (const dimension of GasDimensions) {
+    for (const dimension of GAS_DIMENSIONS) {
       this[`${dimension}Left`] -= gasCost[dimension] ?? 0;
     }
   }
 
   /** Increases the gas left by the amounts specified. */
   public refundGas(gasRefund: Partial<Gas>) {
-    for (const dimension of GasDimensions) {
+    for (const dimension of GAS_DIMENSIONS) {
       this[`${dimension}Left`] += gasRefund[dimension] ?? 0;
     }
   }
@@ -133,7 +133,7 @@ export class AvmMachineState {
    * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
    */
   private exceptionalHalt() {
-    GasDimensions.forEach(dimension => (this[`${dimension}Left`] = 0));
+    GAS_DIMENSIONS.forEach(dimension => (this[`${dimension}Left`] = 0));
     this.reverted = true;
     this.halted = true;
   }

package/src/avm/avm_memory_types.ts

@@ -1,3 +1,12 @@
+import {
+  MEM_TAG_FF,
+  MEM_TAG_U1,
+  MEM_TAG_U8,
+  MEM_TAG_U16,
+  MEM_TAG_U32,
+  MEM_TAG_U64,
+  MEM_TAG_U128,
+} from '@aztec/circuits.js';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
@@ -128,6 +137,9 @@ function UnsignedIntegerClassFactory(bits: number) {
     }
 
     public toBuffer(): Buffer {
+      if (bits < 8) {
+        return toBufferBE(this.n, 1);
+      }
       return toBufferBE(this.n, bits / 8);
     }
   };
@@ -136,6 +148,7 @@ function UnsignedIntegerClassFactory(bits: number) {
 // Now we can create the classes for each unsigned integer type.
 // We extend instead of just assigning so that the class has the right name.
 // Otherwise they are all called "NewUintClass".
+export class Uint1 extends UnsignedIntegerClassFactory(1) {}
 export class Uint8 extends UnsignedIntegerClassFactory(8) {}
 export class Uint16 extends UnsignedIntegerClassFactory(16) {}
 export class Uint32 extends UnsignedIntegerClassFactory(32) {}
@@ -196,12 +209,13 @@ export class Field extends MemoryValue {
 
 export enum TypeTag {
   UNINITIALIZED,
-  UINT8,
-  UINT16,
-  UINT32,
-  UINT64,
-  UINT128,
-  FIELD,
+  UINT1 = MEM_TAG_U1,
+  UINT8 = MEM_TAG_U8,
+  UINT16 = MEM_TAG_U16,
+  UINT32 = MEM_TAG_U32,
+  UINT64 = MEM_TAG_U64,
+  UINT128 = MEM_TAG_U128,
+  FIELD = MEM_TAG_FF,
   INVALID,
 }
 
@@ -302,7 +316,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {
-    if (![TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)) {
+    if (
+      ![TypeTag.UINT1, TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)
+    ) {
       throw TagCheckError.forTag(TypeTag[tag], 'integral');
     }
   }
@@ -332,8 +348,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
 
     if (v === undefined) {
       tag = TypeTag.UNINITIALIZED;
-    } else if (v instanceof Field) {
-      tag = TypeTag.FIELD;
+    } else if (v instanceof Uint1) {
+      tag = TypeTag.UINT1;
     } else if (v instanceof Uint8) {
       tag = TypeTag.UINT8;
     } else if (v instanceof Uint16) {
@@ -344,6 +360,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
       tag = TypeTag.UINT64;
     } else if (v instanceof Uint128) {
       tag = TypeTag.UINT128;
+    } else if (v instanceof Field) {
+      tag = TypeTag.FIELD;
     }
 
     return tag;
@@ -353,6 +371,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public static buildFromTagTruncating(v: bigint | number, tag: TypeTag): MemoryValue {
     v = BigInt(v);
     switch (tag) {
+      case TypeTag.UINT1:
+        return new Uint1(v & 1n);
       case TypeTag.UINT8:
         return new Uint8(v & ((1n << 8n) - 1n));
       case TypeTag.UINT16:
@@ -373,6 +393,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   // Does not truncate. Type constructor will check that it fits.
   public static buildFromTagOrDie(v: bigint | number, tag: TypeTag): MemoryValue {
     switch (tag) {
+      case TypeTag.UINT1:
+        return new Uint1(v);
       case TypeTag.UINT8:
         return new Uint8(v);
       case TypeTag.UINT16:
@@ -391,7 +413,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   /** No-op. Implemented here for compatibility with the MeteredTaggedMemory. */
-  public assert(_operations: Partial<MemoryOperations & { indirect: number }>) {}
+  public assert(_operations: Partial<MemoryOperations & { addressing: Addressing }>) {}
 }
 
 /** Tagged memory wrapper with metering for each memory read and write operation. */
@@ -413,10 +435,15 @@ export class MeteredTaggedMemory implements TaggedMemoryInterface {
    * Asserts that the exact number of memory operations have been performed.
    * Indirect represents the flags for indirect accesses: each bit set to one counts as an extra read.
    */
-  public assert(operations: Partial<MemoryOperations & { indirect: number }>) {
-    const { reads: expectedReads, writes: expectedWrites, indirect } = { reads: 0, writes: 0, ...operations };
-
-    const totalExpectedReads = expectedReads + Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+  public assert(operations: Partial<MemoryOperations & { addressing: Addressing }>) {
+    const {
+      reads: expectedReads,
+      writes: expectedWrites,
+      addressing,
+    } = { reads: 0, writes: 0, addressing: new Addressing([]), ...operations };
+
+    const totalExpectedReads =
+      expectedReads + addressing.count(AddressingMode.INDIRECT) + addressing.count(AddressingMode.RELATIVE);
     const { reads: actualReads, writes: actualWrites } = this.reset();
     if (actualReads !== totalExpectedReads) {
       throw new InstructionExecutionError(

package/src/avm/avm_simulator.ts

@@ -4,7 +4,7 @@ import { strict as assert } from 'assert';
 
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
-import { decompressBytecodeIfCompressed, isAvmBytecode } from './bytecode_utils.js';
+import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
   InvalidProgramCounterError,
@@ -53,11 +53,10 @@ export class AvmSimulator {
    * This method is useful for testing and debugging.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
-    const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
-    assert(await isAvmBytecode(decompressedBytecode), "AVM simulator can't execute non-AVM bytecode");
+    assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
 
-    this.bytecode = decompressedBytecode;
-    return await this.executeInstructions(decodeFromBytecode(decompressedBytecode));
+    this.bytecode = bytecode;
+    return await this.executeInstructions(decodeFromBytecode(bytecode));
   }
 
   /**

package/src/avm/bytecode_utils.ts

@@ -1,6 +1,3 @@
-import { promisify } from 'util';
-import { gunzip } from 'zlib';
-
 import { Opcode } from './serialization/instruction_serialization.js';
 
 const AVM_MAGIC_SUFFIX = Buffer.from([
@@ -14,19 +11,7 @@ export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
   return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
 }
 
-// This is just a helper function for the AVM simulator
-export async function decompressBytecodeIfCompressed(bytecode: Buffer): Promise<Buffer> {
-  try {
-    return await promisify(gunzip)(bytecode);
-  } catch {
-    // If the bytecode is not compressed, the gunzip call will throw an error
-    // In this case, we assume the bytecode is not compressed and continue.
-    return Promise.resolve(bytecode);
-  }
-}
-
-export async function isAvmBytecode(bytecode: Buffer): Promise<boolean> {
-  const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
+export function isAvmBytecode(bytecode: Buffer): boolean {
   const magicSize = AVM_MAGIC_SUFFIX.length;
-  return decompressedBytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+  return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
 }

package/src/avm/errors.ts

@@ -1,5 +1,5 @@
 import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { type AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
 
 import { ExecutionError } from '../common/errors.js';
 import { type AvmContext } from './avm_context.js';
@@ -109,13 +109,21 @@ export class AvmRevertReason extends ExecutionError {
  * @param nestedError - the error that caused this one (if this is not the root-cause itself)
  */
 function createRevertReason(message: string, context: AvmContext, nestedError?: AvmRevertReason): AvmRevertReason {
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
+  // If the function selector is the public dispatch selector, we need to extract the actual function selector from the calldata.
+  // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
+  let functionSelector = context.environment.functionSelector;
+  const internalCallStack = context.machineState.internalCallStack;
+  if (functionSelector.toField().equals(new Fr(PUBLIC_DISPATCH_SELECTOR)) && context.environment.calldata.length > 0) {
+    functionSelector = FunctionSelector.fromField(context.environment.calldata[0]);
+  }
   return new AvmRevertReason(
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionSelector: context.environment.functionSelector,
+      functionSelector: functionSelector,
     },
-    /*noirCallStack=*/ [...context.machineState.internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
+    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },
   );
 }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
-import { GasFees, GlobalVariables, Header } from '@aztec/circuits.js';
+import { GasFees, GlobalVariables } from '@aztec/circuits.js';
 import { FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -10,20 +10,13 @@ import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
-import {
-  type CommitmentsDB,
-  type PublicContractsDB,
-  type PublicStateDB,
-  resolveAssertionMessage,
-  traverseCauseChain,
-} from '../../index.js';
+import { type WorldStateDB, resolveAssertionMessage, traverseCauseChain } from '../../index.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
-import { AvmContextInputs, AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
-import { Field, Uint8, Uint64 } from '../avm_memory_types.js';
+import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
 import { type AvmRevertReason } from '../errors.js';
-import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
 import { NullifierManager } from '../journal/nullifiers.js';
 import { PublicStorage } from '../journal/public_storage.js';
@@ -43,32 +36,19 @@ export function initContext(overrides?: {
   );
 }
 
-/** Creates an empty host storage with mocked dbs. */
-export function initHostStorage(overrides?: {
-  publicDb?: PublicStateDB;
-  contractsDb?: PublicContractsDB;
-  commitmentsDb?: CommitmentsDB;
-}): HostStorage {
-  return new HostStorage(
-    overrides?.publicDb || mock<PublicStateDB>(),
-    overrides?.contractsDb || mock<PublicContractsDB>(),
-    overrides?.commitmentsDb || mock<CommitmentsDB>(),
-  );
-}
-
 /** Creates an empty state manager with mocked host storage. */
 export function initPersistableStateManager(overrides?: {
-  hostStorage?: HostStorage;
+  worldStateDB?: WorldStateDB;
   trace?: PublicSideEffectTraceInterface;
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
 }): AvmPersistableStateManager {
-  const hostStorage = overrides?.hostStorage || initHostStorage();
+  const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
   return new AvmPersistableStateManager(
-    hostStorage,
+    worldStateDB,
     overrides?.trace || mock<PublicSideEffectTraceInterface>(),
-    overrides?.publicStorage || new PublicStorage(hostStorage.publicStateDb),
-    overrides?.nullifiers || new NullifierManager(hostStorage.commitmentsDb),
+    overrides?.publicStorage || new PublicStorage(worldStateDB),
+    overrides?.nullifiers || new NullifierManager(worldStateDB),
   );
 }
 
@@ -83,7 +63,6 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
     overrides?.transactionFee ?? Fr.zero(),
-    overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,
@@ -124,26 +103,14 @@ export function allSameExcept(original: any, overrides: any): any {
   return merge({}, original, overrides);
 }
 
-/**
- * Adjust the user index to account for the AvmContextInputs size.
- * This is a hack for testing, and should go away once AvmContextInputs themselves go away.
- */
-export function adjustCalldataIndex(userIndex: number): number {
-  return userIndex + AvmContextInputs.SIZE;
-}
-
-export function anyAvmContextInputs() {
-  const tv = [];
-  for (let i = 0; i < AvmContextInputs.SIZE; i++) {
-    tv.push(expect.any(Fr));
-  }
-  return tv;
-}
-
 export function randomMemoryBytes(length: number): Uint8[] {
   return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
 }
 
+export function randomMemoryUint32s(length: number): Uint32[] {
+  return [...Array(length)].map(_ => new Uint32(Math.floor(Math.random() * 255)));
+}
+
 export function randomMemoryUint64s(length: number): Uint64[] {
   return [...Array(length)].map(_ => new Uint64(Math.floor(Math.random() * 255)));
 }

package/src/avm/journal/index.ts

@@ -1,2 +1 @@
-export * from './host_storage.js';
 export * from './journal.js';