@aztec/simulator 0.48.0 → 0.50.1

package/src/avm/avm_gas.ts

@@ -1,3 +1,5 @@
+import * as c from '@aztec/circuits.js/constants';
+
 import { TypeTag } from './avm_memory_types.js';
 import { InstructionExecutionError } from './errors.js';
 import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
@@ -46,90 +48,150 @@ export const EmptyGas: Gas = {
   daGas: 0,
 };
 
+function makeCost(l2Gas: number, daGas: number): Gas {
+  return { l2Gas, daGas };
+}
+
 /** Dimensions of gas usage: L1, L2, and DA. */
 export const GasDimensions = ['l2Gas', 'daGas'] as const;
 
-/** Default gas cost for an opcode. */
-const DefaultBaseGasCost: Gas = { l2Gas: 10, daGas: 0 };
-
 /** 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> = {
-  [Opcode.ADD]: DefaultBaseGasCost,
-  [Opcode.SUB]: DefaultBaseGasCost,
-  [Opcode.MUL]: DefaultBaseGasCost,
-  [Opcode.DIV]: DefaultBaseGasCost,
-  [Opcode.FDIV]: DefaultBaseGasCost,
-  [Opcode.EQ]: DefaultBaseGasCost,
-  [Opcode.LT]: DefaultBaseGasCost,
-  [Opcode.LTE]: DefaultBaseGasCost,
-  [Opcode.AND]: DefaultBaseGasCost,
-  [Opcode.OR]: DefaultBaseGasCost,
-  [Opcode.XOR]: DefaultBaseGasCost,
-  [Opcode.NOT]: DefaultBaseGasCost,
-  [Opcode.SHL]: DefaultBaseGasCost,
-  [Opcode.SHR]: DefaultBaseGasCost,
-  [Opcode.CAST]: DefaultBaseGasCost,
-  // Execution environment
-  [Opcode.ADDRESS]: DefaultBaseGasCost,
-  [Opcode.STORAGEADDRESS]: DefaultBaseGasCost,
-  [Opcode.SENDER]: DefaultBaseGasCost,
-  [Opcode.FEEPERL2GAS]: DefaultBaseGasCost,
-  [Opcode.FEEPERDAGAS]: DefaultBaseGasCost,
-  [Opcode.TRANSACTIONFEE]: DefaultBaseGasCost,
-  [Opcode.FUNCTIONSELECTOR]: DefaultBaseGasCost,
-  [Opcode.CHAINID]: DefaultBaseGasCost,
-  [Opcode.VERSION]: DefaultBaseGasCost,
-  [Opcode.BLOCKNUMBER]: DefaultBaseGasCost,
-  [Opcode.TIMESTAMP]: DefaultBaseGasCost,
-  [Opcode.COINBASE]: DefaultBaseGasCost,
-  [Opcode.BLOCKL2GASLIMIT]: DefaultBaseGasCost,
-  [Opcode.BLOCKDAGASLIMIT]: DefaultBaseGasCost,
-  [Opcode.CALLDATACOPY]: DefaultBaseGasCost,
-  // Gas
-  [Opcode.L2GASLEFT]: DefaultBaseGasCost,
-  [Opcode.DAGASLEFT]: DefaultBaseGasCost,
-  // Control flow
-  [Opcode.JUMP]: DefaultBaseGasCost,
-  [Opcode.JUMPI]: DefaultBaseGasCost,
-  [Opcode.INTERNALCALL]: DefaultBaseGasCost,
-  [Opcode.INTERNALRETURN]: DefaultBaseGasCost,
-  // Memory
-  [Opcode.SET]: DefaultBaseGasCost,
-  [Opcode.MOV]: DefaultBaseGasCost,
-  [Opcode.CMOV]: DefaultBaseGasCost,
-  // World state
-  [Opcode.SLOAD]: DefaultBaseGasCost,
-  [Opcode.SSTORE]: DefaultBaseGasCost,
-  [Opcode.NOTEHASHEXISTS]: DefaultBaseGasCost,
-  [Opcode.EMITNOTEHASH]: DefaultBaseGasCost,
-  [Opcode.NULLIFIEREXISTS]: DefaultBaseGasCost,
-  [Opcode.EMITNULLIFIER]: DefaultBaseGasCost,
-  [Opcode.L1TOL2MSGEXISTS]: DefaultBaseGasCost,
-  [Opcode.HEADERMEMBER]: DefaultBaseGasCost,
-  [Opcode.EMITUNENCRYPTEDLOG]: DefaultBaseGasCost,
-  [Opcode.SENDL2TOL1MSG]: DefaultBaseGasCost,
-  [Opcode.GETCONTRACTINSTANCE]: DefaultBaseGasCost,
-  // External calls
-  [Opcode.CALL]: DefaultBaseGasCost,
-  [Opcode.STATICCALL]: DefaultBaseGasCost,
-  [Opcode.DELEGATECALL]: DefaultBaseGasCost,
-  [Opcode.RETURN]: DefaultBaseGasCost,
-  [Opcode.REVERT]: DefaultBaseGasCost,
-  // Misc
-  [Opcode.DEBUGLOG]: DefaultBaseGasCost,
-  // Gadgets
-  [Opcode.KECCAK]: DefaultBaseGasCost,
-  [Opcode.POSEIDON2]: DefaultBaseGasCost,
-  [Opcode.SHA256]: DefaultBaseGasCost,
-  [Opcode.PEDERSEN]: DefaultBaseGasCost,
-  [Opcode.ECADD]: DefaultBaseGasCost,
-  [Opcode.MSM]: DefaultBaseGasCost,
-  [Opcode.PEDERSENCOMMITMENT]: DefaultBaseGasCost,
-  // Conversions
-  [Opcode.TORADIXLE]: DefaultBaseGasCost,
-  // Other
-  [Opcode.SHA256COMPRESSION]: DefaultBaseGasCost,
-  [Opcode.KECCAKF1600]: DefaultBaseGasCost,
+  [Opcode.ADD]: makeCost(c.AVM_ADD_BASE_L2_GAS, 0),
+  [Opcode.SUB]: makeCost(c.AVM_SUB_BASE_L2_GAS, 0),
+  [Opcode.MUL]: makeCost(c.AVM_MUL_BASE_L2_GAS, 0),
+  [Opcode.DIV]: makeCost(c.AVM_DIV_BASE_L2_GAS, 0),
+  [Opcode.FDIV]: makeCost(c.AVM_FDIV_BASE_L2_GAS, 0),
+  [Opcode.EQ]: makeCost(c.AVM_EQ_BASE_L2_GAS, 0),
+  [Opcode.LT]: makeCost(c.AVM_LT_BASE_L2_GAS, 0),
+  [Opcode.LTE]: makeCost(c.AVM_LTE_BASE_L2_GAS, 0),
+  [Opcode.AND]: makeCost(c.AVM_AND_BASE_L2_GAS, 0),
+  [Opcode.OR]: makeCost(c.AVM_OR_BASE_L2_GAS, 0),
+  [Opcode.XOR]: makeCost(c.AVM_XOR_BASE_L2_GAS, 0),
+  [Opcode.NOT]: makeCost(c.AVM_NOT_BASE_L2_GAS, 0),
+  [Opcode.SHL]: makeCost(c.AVM_SHL_BASE_L2_GAS, 0),
+  [Opcode.SHR]: makeCost(c.AVM_SHR_BASE_L2_GAS, 0),
+  [Opcode.CAST]: 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.COINBASE]: makeCost(c.AVM_COINBASE_BASE_L2_GAS, 0),
+  [Opcode.BLOCKL2GASLIMIT]: makeCost(c.AVM_BLOCKL2GASLIMIT_BASE_L2_GAS, 0),
+  [Opcode.BLOCKDAGASLIMIT]: makeCost(c.AVM_BLOCKDAGASLIMIT_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]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
+  [Opcode.JUMPI]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
+  [Opcode.INTERNALCALL]: makeCost(c.AVM_INTERNALCALL_BASE_L2_GAS, 0),
+  [Opcode.INTERNALRETURN]: makeCost(c.AVM_INTERNALRETURN_BASE_L2_GAS, 0),
+  [Opcode.SET]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
+  [Opcode.MOV]: 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.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
+  [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, 0),
+  [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
+  [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, 0),
+  [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
+  [Opcode.HEADERMEMBER]: makeCost(c.AVM_HEADERMEMBER_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.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),
+  [Opcode.DELEGATECALL]: makeCost(c.AVM_DELEGATECALL_BASE_L2_GAS, 0),
+  [Opcode.RETURN]: makeCost(c.AVM_RETURN_BASE_L2_GAS, 0),
+  [Opcode.REVERT]: makeCost(c.AVM_REVERT_BASE_L2_GAS, 0),
+  [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.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]: makeCost(c.AVM_ADD_DYN_L2_GAS, 0),
+  [Opcode.SUB]: makeCost(c.AVM_SUB_DYN_L2_GAS, 0),
+  [Opcode.MUL]: makeCost(c.AVM_MUL_DYN_L2_GAS, 0),
+  [Opcode.DIV]: makeCost(c.AVM_DIV_DYN_L2_GAS, 0),
+  [Opcode.FDIV]: makeCost(c.AVM_FDIV_DYN_L2_GAS, 0),
+  [Opcode.EQ]: makeCost(c.AVM_EQ_DYN_L2_GAS, 0),
+  [Opcode.LT]: makeCost(c.AVM_LT_DYN_L2_GAS, 0),
+  [Opcode.LTE]: makeCost(c.AVM_LTE_DYN_L2_GAS, 0),
+  [Opcode.AND]: makeCost(c.AVM_AND_DYN_L2_GAS, 0),
+  [Opcode.OR]: makeCost(c.AVM_OR_DYN_L2_GAS, 0),
+  [Opcode.XOR]: makeCost(c.AVM_XOR_DYN_L2_GAS, 0),
+  [Opcode.NOT]: makeCost(c.AVM_NOT_DYN_L2_GAS, 0),
+  [Opcode.SHL]: makeCost(c.AVM_SHL_DYN_L2_GAS, 0),
+  [Opcode.SHR]: makeCost(c.AVM_SHR_DYN_L2_GAS, 0),
+  [Opcode.CAST]: 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.COINBASE]: makeCost(c.AVM_COINBASE_DYN_L2_GAS, 0),
+  [Opcode.BLOCKL2GASLIMIT]: makeCost(c.AVM_BLOCKL2GASLIMIT_DYN_L2_GAS, 0),
+  [Opcode.BLOCKDAGASLIMIT]: makeCost(c.AVM_BLOCKDAGASLIMIT_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]: makeCost(c.AVM_JUMP_DYN_L2_GAS, 0),
+  [Opcode.JUMPI]: 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]: makeCost(c.AVM_SET_DYN_L2_GAS, 0),
+  [Opcode.MOV]: 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.HEADERMEMBER]: makeCost(c.AVM_HEADERMEMBER_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]: 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),
 };
 
 /** Returns the fixed base gas cost for a given opcode. */
@@ -137,6 +199,10 @@ export function getBaseGasCost(opcode: Opcode): Gas {
   return BaseGasCosts[opcode];
 }
 
+export function getDynamicGasCost(opcode: Opcode): Gas {
+  return DynamicGasCosts[opcode];
+}
+
 /** Returns the gas cost associated with the memory operations performed. */
 export function getMemoryGasCost(args: { reads?: number; writes?: number; indirect?: number }) {
   const { reads, writes, indirect } = args;

package/src/avm/opcodes/accrued_substate.ts

@@ -241,7 +241,7 @@ export class EmitUnencryptedLog extends Instruction {
     const contractAddress = context.environment.address;
 
     const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: logSize }));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
     context.persistableState.writeUnencryptedLog(contractAddress, log);
 

package/src/avm/opcodes/conversion.ts

@@ -35,7 +35,7 @@ export class ToRadixLE extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
     const memoryOperations = { reads: 1, writes: this.numLimbs, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.numLimbs }));
 
     // The radix gadget only takes in a Field
     memory.checkTag(TypeTag.FIELD, srcOffset);

package/src/avm/opcodes/external_calls.ts

@@ -67,7 +67,7 @@ abstract class ExternalCall extends Instruction {
 
     // First we consume the gas for this operation.
     const memoryOperations = { reads: calldataSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: calldataSize + this.retSize }));
     // Then we consume the gas allocated for the nested call. The excess will be refunded later.
     // Gas allocation is capped by the amount of gas left in the current context.
     // We have to do some dancing here because the gas allocation is a field,
@@ -170,7 +170,7 @@ export class Return extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { reads: this.copySize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.copySize }));
 
     const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 
@@ -199,7 +199,7 @@ export class Revert extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { reads: this.retSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.retSize }));
 
     const [returnOffset] = Addressing.fromWire(this.indirect).resolve([this.returnOffset], memory);
 

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, sumGas } from '../avm_gas.js';
+import { getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -67,12 +67,15 @@ export abstract class Instruction {
    * @param memoryOps Memory operations performed by the instruction.
    * @returns Gas cost.
    */
-  protected gasCost(_memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+  protected gasCost(ops: Partial<MemoryOperations & { indirect: number; dynMultiplier: number }> = {}) {
     const baseGasCost = getBaseGasCost(this.opcode);
+    // TODO: We are using a simplified gas model to reduce complexity in the circuit.
+    // Memory accounting will probably be removed.
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6861): reconsider.
     // const memoryGasCost = getMemoryGasCost(memoryOps);
-    const memoryGasCost = { l2Gas: 0, daGas: 0 };
-    return sumGas(baseGasCost, memoryGasCost);
+    // const memoryGasCost = { l2Gas: 0, daGas: 0 };
+    const dynGasCost = mulGas(getDynamicGasCost(this.opcode), ops.dynMultiplier ?? 0);
+    return sumGas(baseGasCost, dynGasCost);
   }
 
   /**

package/src/avm/opcodes/memory.ts

@@ -208,7 +208,7 @@ export class CalldataCopy extends Instruction {
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { writes: this.copySize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.copySize }));
 
     // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
     const [cdOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.cdOffset, this.dstOffset], memory);

package/src/avm/opcodes/storage.ts

@@ -42,7 +42,7 @@ export class SStore extends BaseStorageInstruction {
 
     const memoryOperations = { reads: this.size + 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.size }));
 
     const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);
@@ -72,7 +72,7 @@ export class SLoad extends BaseStorageInstruction {
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { writes: this.size, reads: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.size }));
 
     const [slotOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);

package/src/providers/acvm_native.ts

@@ -156,6 +156,6 @@ export class NativeACVMSimulator implements SimulationProvider {
       return result.witness;
     };
 
-    return await runInDirectory(this.workingDirectory, operation);
+    return await runInDirectory(this.workingDirectory, operation, false);
   }
 }

package/src/public/public_processor.ts

@@ -1,8 +1,8 @@
 import {
-  type BlockProver,
   type FailedTx,
   NestedProcessReturnValues,
   type ProcessedTx,
+  type ProcessedTxHandler,
   PublicKernelType,
   type PublicProvingRequest,
   type SimulationError,
@@ -116,12 +116,13 @@ export class PublicProcessor {
   /**
    * Run each tx through the public circuit and the public kernel circuit if needed.
    * @param txs - Txs to process.
+   * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
   public async process(
     txs: Tx[],
     maxTransactions = txs.length,
-    blockProver?: BlockProver,
+    processedTxHandler?: ProcessedTxHandler,
     txValidator?: TxValidator<ProcessedTx>,
   ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
@@ -164,9 +165,9 @@ export class PublicProcessor {
             throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
           }
         }
-        // if we were given a prover then send the transaction to it for proving
-        if (blockProver) {
-          await blockProver.addNewTx(processedTx);
+        // if we were given a handler then send the transaction to it for block building or proving
+        if (processedTxHandler) {
+          await processedTxHandler.addNewTx(processedTx);
         }
         result.push(processedTx);
         returns = returns.concat(returnValues ?? []);

package/src/public/public_processor_metrics.ts

@@ -85,6 +85,8 @@ export class PublicProcessorMetrics {
       totalBytecode += event.packedPublicBytecode.length;
     }
 
-    this.bytecodeDeployed.record(totalBytecode);
+    if (totalBytecode > 0) {
+      this.bytecodeDeployed.record(totalBytecode);
+    }
   }
 }

package/src/rollup/rollup.ts

@@ -3,6 +3,9 @@ import {
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
   type BaseRollupInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
   type MergeRollupInputs,
   type ParityPublicInputs,
   type RootParityInputs,
@@ -15,6 +18,10 @@ import {
   SimulatedServerCircuitArtifacts,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
+  convertBlockMergeRollupInputsToWitnessMap,
+  convertBlockMergeRollupOutputsFromWitnessMap,
+  convertBlockRootRollupInputsToWitnessMap,
+  convertBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertRootParityInputsToWitnessMap,
@@ -56,6 +63,18 @@ export interface RollupSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs>;
+  /**
+   * Simulates the block root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  blockRootRollupCircuit(input: BlockRootRollupInputs): Promise<BlockRootOrBlockMergePublicInputs>;
+  /**
+   * Simulates the block merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  blockMergeRollupCircuit(input: BlockMergeRollupInputs): Promise<BlockRootOrBlockMergePublicInputs>;
   /**
    * Simulates the root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -128,6 +147,7 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
 
     return Promise.resolve(result);
   }
+
   /**
    * Simulates the merge rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -146,6 +166,42 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
     return result;
   }
 
+  /**
+   * Simulates the block root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async blockRootRollupCircuit(input: BlockRootRollupInputs): Promise<BlockRootOrBlockMergePublicInputs> {
+    const witnessMap = convertBlockRootRollupInputsToWitnessMap(input);
+
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BlockRootRollupArtifact,
+    );
+
+    const result = convertBlockRootRollupOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
+  /**
+   * Simulates the block merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async blockMergeRollupCircuit(input: BlockMergeRollupInputs): Promise<BlockRootOrBlockMergePublicInputs> {
+    const witnessMap = convertBlockMergeRollupInputsToWitnessMap(input);
+
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BlockMergeRollupArtifact,
+    );
+
+    const result = convertBlockMergeRollupOutputsFromWitnessMap(witness);
+
+    return Promise.resolve(result);
+  }
+
   /**
    * Simulates the root rollup circuit from its inputs.
    * @param input - Inputs to the circuit.