@aztec/simulator 0.47.1 → 0.49.2

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/fixtures/index.ts

@@ -91,6 +91,7 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
     overrides?.chainId ?? Fr.zero(),
     overrides?.version ?? Fr.zero(),
     overrides?.blockNumber ?? Fr.zero(),
+    overrides?.slotNumber ?? Fr.zero(),
     overrides?.timestamp ?? Fr.zero(),
     overrides?.coinbase ?? EthAddress.ZERO,
     overrides?.feeRecipient ?? AztecAddress.zero(),

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/commitment.ts

@@ -43,15 +43,15 @@ export class PedersenCommitment extends Instruction {
     const inputs = memory.getSlice(inputOffset, inputSize);
     memory.checkTagsRange(TypeTag.FIELD, inputOffset, inputSize);
 
-    // Generator index not used for now since we dont utilise it in the pedersenCommit function
+    const generatorIndex = memory.get(genIndexOffset).toNumber();
     memory.checkTag(TypeTag.UINT32, genIndexOffset);
 
-    const memoryOperations = { reads: inputSize + 1, writes: 3, indirect: this.indirect };
+    const memoryOperations = { reads: inputSize + 2, writes: 3, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     const inputBuffer: Buffer[] = inputs.map(input => input.toBuffer());
     // TODO: Add the generate index to the pedersenCommit function
-    const commitment = pedersenCommit(inputBuffer).map(f => new Field(f));
+    const commitment = pedersenCommit(inputBuffer, generatorIndex).map(f => new Field(f));
     // The function doesnt include a flag if the output point is infinity, come back to this
     // for now we just check if theyre zero - until we know how bb encodes them
     const isInfinity = commitment[0].equals(new Field(0)) && commitment[1].equals(new Field(0));

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/avm/serialization/instruction_serialization.ts

@@ -87,7 +87,7 @@ export enum Opcode {
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
-// See vm/avm_trace/avm_deserialization.cpp)
+// See vm/avm_trace/deserialization.cpp)
 // Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
 // this one is parsed as UINT8.
 export enum OperandType {

package/src/client/client_execution_context.ts

@@ -30,7 +30,7 @@ import {
   countArgumentsSize,
 } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { pedersenHash } from '@aztec/foundation/crypto';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
@@ -71,7 +71,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
-  private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
@@ -94,8 +94,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
     log = createDebugLogger('aztec:simulator:client_execution_context'),
+    scopes?: AztecAddress[],
   ) {
-    super(contractAddress, authWitnesses, db, node, log);
+    super(contractAddress, authWitnesses, db, node, log, scopes);
   }
 
   // We still need this function until we can get user-defined ordering of structs for fn arguments
@@ -135,14 +136,13 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Get the data for the newly created notes.
-   * @param innerNoteHashes - Inner note hashes for the notes.
    */
   public getNewNotes(): NoteAndSlot[] {
     return this.newNotes;
   }
 
-  public getNullifiedNoteHashCounters() {
-    return this.nullifiedNoteHashCounters;
+  public getNoteHashNullifierCounterMap() {
+    return this.noteHashNullifierCounterMap;
   }
 
   /**
@@ -251,7 +251,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const pendingNotes = this.noteCache.getNotes(this.callContext.storageContractAddress, storageSlot);
 
     const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.storageContractAddress);
-    const dbNotes = await this.db.getNotes(this.callContext.storageContractAddress, storageSlot, status);
+    const dbNotes = await this.db.getNotes(this.callContext.storageContractAddress, storageSlot, status, this.scopes);
     const dbNotesFiltered = dbNotes.filter(n => !pendingNullifiers.has((n.siloedNullifier as Fr).value));
 
     const notes = pickNotes<NoteData>([...dbNotesFiltered, ...pendingNotes], {
@@ -276,12 +276,9 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     notes.forEach(n => {
       if (n.index !== undefined) {
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
-        // Should always call computeUniqueNoteHash when publicly created notes include nonces.
-        const uniqueNoteHash = n.nonce.isZero() ? n.innerNoteHash : computeUniqueNoteHash(n.nonce, n.innerNoteHash);
+        const uniqueNoteHash = computeUniqueNoteHash(n.nonce, n.noteHash);
         const siloedNoteHash = siloNoteHash(n.contractAddress, uniqueNoteHash);
-        const noteHashForReadRequest = siloedNoteHash;
-        this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
+        this.noteHashLeafIndexMap.set(siloedNoteHash.toBigInt(), n.index);
       }
     });
 
@@ -295,14 +292,14 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The type ID of the note.
    * @param noteItems - The items to be included in a Note.
-   * @param innerNoteHash - The inner note hash of the new note.
+   * @param noteHash - A hash of the new note.
    * @returns
    */
   public override notifyCreatedNote(
     storageSlot: Fr,
     noteTypeId: NoteSelector,
     noteItems: Fr[],
-    innerNoteHash: Fr,
+    noteHash: Fr,
     counter: number,
   ) {
     const note = new Note(noteItems);
@@ -313,7 +310,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         nonce: Fr.ZERO, // Nonce cannot be known during private execution.
         note,
         siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
-        innerNoteHash,
+        noteHash,
       },
       counter,
     );
@@ -328,16 +325,16 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Adding a siloed nullifier into the current set of all pending nullifiers created
    * within the current transaction/execution.
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
-   * @param innerNoteHash - The inner note hash of the new note.
+   * @param noteHash - A hash of the new note.
    */
-  public override notifyNullifiedNote(innerNullifier: Fr, innerNoteHash: Fr, counter: number) {
+  public override notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     const nullifiedNoteHashCounter = this.noteCache.nullifyNote(
       this.callContext.storageContractAddress,
       innerNullifier,
-      innerNoteHash,
+      noteHash,
     );
     if (nullifiedNoteHashCounter !== undefined) {
-      this.nullifiedNoteHashCounters.set(nullifiedNoteHashCounter, counter);
+      this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
     }
     return Promise.resolve();
   }
@@ -360,7 +357,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // An app providing randomness = 0 signals to not mask the address.
     const maskedContractAddress = randomness.isZero()
       ? contractAddress.toField()
-      : pedersenHash([contractAddress, randomness], 0);
+      : poseidon2HashWithSeparator([contractAddress, randomness], 0);
     const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedEvent, maskedContractAddress), counter);
     this.encryptedLogs.push(encryptedLog);
   }
@@ -519,6 +516,8 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.db,
       this.node,
       sideEffectCounter,
+      this.log,
+      this.scopes,
     );
 
     const childExecutionResult = await executePrivateFunction(
@@ -645,6 +644,10 @@ export class ClientExecutionContext extends ViewDataOracle {
     );
   }
 
+  public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): void {
+    this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+  }
+
   /**
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.

package/src/client/db_oracle.ts

@@ -78,12 +78,18 @@ export interface DBOracle extends CommitmentsDB {
    * The query result is paginated using 'limit' and 'offset' values.
    * Returns an object containing an array of note data.
    *
-   * @param contractAddress - The AztecAddress instance representing the contract address.
-   * @param storageSlot - The Fr instance representing the storage slot of the notes.
+   * @param contractAddress - The contract address of the notes.
+   * @param storageSlot - The storage slot of the notes.
    * @param status - The status of notes to fetch.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    * @returns A Promise that resolves to an array of note data.
    */
-  getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus): Promise<NoteData[]>;
+  getNotes(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    status: NoteStatus,
+    scopes?: AztecAddress[],
+  ): Promise<NoteData[]>;
 
   /**
    * Retrieve the artifact information of a specific function within a contract.