@aztec/simulator 0.32.1 → 0.34.0

package/dest/public/transitional_adaptors.js

@@ -0,0 +1,161 @@
+// All code in this file needs to die once the public executor is phased out in favor of the AVM.
+import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { CallContext, ContractStorageRead, ContractStorageUpdateRequest, FunctionData, L2ToL1Message, ReadRequest, SideEffect, SideEffectLinkedToNoteHash, } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
+import { Mov } from '../avm/opcodes/memory.js';
+import { createSimulationError } from '../common/errors.js';
+import { PackedArgsCache, SideEffectCounter } from '../index.js';
+import { PublicExecutionContext } from './public_execution_context.js';
+/**
+ * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
+ *
+ * @param current
+ * @param globalVariables
+ * @returns
+ */
+export function createAvmExecutionEnvironment(current, header, globalVariables) {
+    return new AvmExecutionEnvironment(current.contractAddress, current.callContext.storageContractAddress, current.callContext.msgSender, // TODO: origin is not available
+    current.callContext.msgSender, current.callContext.portalContractAddress, 
+    /*feePerL1Gas=*/ Fr.zero(), 
+    /*feePerL2Gas=*/ Fr.zero(), 
+    /*feePerDaGas=*/ Fr.zero(), 
+    /*contractCallDepth=*/ Fr.zero(), header, globalVariables, current.callContext.isStaticCall, current.callContext.isDelegateCall, current.args, current.functionData.selector);
+}
+export function createPublicExecutionContext(avmContext, calldata) {
+    const sideEffectCounter = avmContext.persistableState.trace.accessCounter;
+    const callContext = CallContext.from({
+        msgSender: avmContext.environment.sender,
+        storageContractAddress: avmContext.environment.storageAddress,
+        portalContractAddress: avmContext.environment.portal,
+        functionSelector: avmContext.environment.temporaryFunctionSelector,
+        isDelegateCall: avmContext.environment.isDelegateCall,
+        isStaticCall: avmContext.environment.isStaticCall,
+        sideEffectCounter: sideEffectCounter,
+    });
+    const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+    const execution = {
+        contractAddress: avmContext.environment.address,
+        callContext,
+        args: calldata,
+        functionData,
+    };
+    const packedArgs = PackedArgsCache.create([]);
+    const context = new PublicExecutionContext(execution, avmContext.environment.header, avmContext.environment.globals, packedArgs, new SideEffectCounter(sideEffectCounter), avmContext.persistableState.hostStorage.publicStateDb, avmContext.persistableState.hostStorage.contractsDb, avmContext.persistableState.hostStorage.commitmentsDb);
+    return context;
+}
+/**
+ * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
+ *
+ * @param execution
+ * @param newWorldState
+ * @param result
+ * @returns
+ */
+export async function convertAvmResults(executionContext, newWorldState, result) {
+    const execution = executionContext.execution;
+    const contractStorageReads = newWorldState.storageReads.map(read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber()));
+    const contractStorageUpdateRequests = newWorldState.storageWrites.map(write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber()));
+    // We need to write the storage updates to the DB, because that's what the ACVM expects.
+    // Assumes the updates are in the right order.
+    for (const write of newWorldState.storageWrites) {
+        await executionContext.stateDb.storageWrite(write.storageAddress, write.slot, write.value);
+    }
+    const newNoteHashes = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash.noteHash, noteHash.counter));
+    const nullifierReadRequests = newWorldState.nullifierChecks
+        .filter(nullifierCheck => nullifierCheck.exists)
+        .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+    const nullifierNonExistentReadRequests = newWorldState.nullifierChecks
+        .filter(nullifierCheck => !nullifierCheck.exists)
+        .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+    const newNullifiers = newWorldState.newNullifiers.map(tracedNullifier => new SideEffectLinkedToNoteHash(
+    /*value=*/ tracedNullifier.nullifier, 
+    /*noteHash=*/ Fr.ZERO, // NEEDED?
+    tracedNullifier.counter));
+    const unencryptedLogs = new UnencryptedFunctionL2Logs(newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)));
+    const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
+    const returnValues = result.output;
+    // TODO: Support nested executions.
+    const nestedExecutions = [];
+    // TODO keep track of side effect counters
+    const startSideEffectCounter = Fr.ZERO;
+    const endSideEffectCounter = Fr.ZERO;
+    return {
+        execution,
+        nullifierReadRequests,
+        nullifierNonExistentReadRequests,
+        newNoteHashes,
+        newL2ToL1Messages,
+        startSideEffectCounter,
+        endSideEffectCounter,
+        newNullifiers,
+        contractStorageReads,
+        contractStorageUpdateRequests,
+        returnValues,
+        nestedExecutions,
+        unencryptedLogs,
+        reverted: result.reverted,
+        revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
+    };
+}
+export function convertPublicExecutionResult(res) {
+    return new AvmContractCallResults(res.reverted, res.returnValues, res.revertReason);
+}
+export function updateAvmContextFromPublicExecutionResult(ctx, result) {
+    // We have to push these manually and not use the trace* functions
+    // so that we respect the side effect counters.
+    for (const readRequest of result.contractStorageReads) {
+        ctx.persistableState.trace.publicStorageReads.push({
+            storageAddress: ctx.environment.storageAddress,
+            exists: true, // FIXME
+            slot: readRequest.storageSlot,
+            value: readRequest.currentValue,
+            counter: new Fr(readRequest.sideEffectCounter ?? Fr.ZERO),
+        });
+    }
+    for (const updateRequest of result.contractStorageUpdateRequests) {
+        ctx.persistableState.trace.publicStorageWrites.push({
+            storageAddress: ctx.environment.storageAddress,
+            slot: updateRequest.storageSlot,
+            value: updateRequest.newValue,
+            counter: new Fr(updateRequest.sideEffectCounter ?? Fr.ZERO),
+        });
+        // We need to manually populate the cache.
+        ctx.persistableState.publicStorage.write(ctx.environment.storageAddress, updateRequest.storageSlot, updateRequest.newValue);
+    }
+    for (const nullifier of result.newNullifiers) {
+        ctx.persistableState.trace.newNullifiers.push({
+            storageAddress: ctx.environment.storageAddress,
+            nullifier: nullifier.value,
+            counter: nullifier.counter,
+        });
+    }
+    for (const noteHash of result.newNoteHashes) {
+        ctx.persistableState.trace.newNoteHashes.push({
+            storageAddress: ctx.environment.storageAddress,
+            noteHash: noteHash.value,
+            counter: noteHash.counter,
+        });
+    }
+    for (const message of result.newL2ToL1Messages) {
+        ctx.persistableState.newL1Messages.push(message);
+    }
+    for (const log of result.unencryptedLogs.logs) {
+        ctx.persistableState.newLogs.push(new UnencryptedL2Log(log.contractAddress, log.selector, log.data));
+    }
+}
+const AVM_MAGIC_SUFFIX = Buffer.from([
+    Mov.opcode, // opcode
+    0x00, // indirect
+    ...Buffer.from('000018ca', 'hex'), // srcOffset
+    ...Buffer.from('000018ca', 'hex'), // dstOffset
+]);
+export function markBytecodeAsAvm(bytecode) {
+    return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
+}
+export function isAvmBytecode(bytecode) {
+    const magicSize = AVM_MAGIC_SUFFIX.length;
+    return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transitional_adaptors.js","sourceRoot":"","sources":["../../src/public/transitional_adaptors.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.32.1",
+  "version": "0.34.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -16,24 +16,31 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --passWithNoTests"
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests"
   },
   "inherits": [
     "../package.common.json"
   ],
   "jest": {
-    "preset": "ts-jest/presets/default-esm",
     "moduleNameMapper": {
       "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
     },
     "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest"
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.32.1",
-    "@aztec/circuits.js": "0.32.1",
-    "@aztec/foundation": "0.32.1",
-    "@aztec/types": "0.32.1",
+    "@aztec/circuit-types": "0.34.0",
+    "@aztec/circuits.js": "0.34.0",
+    "@aztec/foundation": "0.34.0",
+    "@aztec/types": "0.34.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "@noir-lang/types": "portal:../../noir/packages/types",
     "levelup": "^5.1.1",
@@ -53,7 +60,6 @@
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.4",
     "lodash.merge": "^4.6.2",
-    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
     "viem": "^2.7.15"

package/src/acvm/acvm.ts

@@ -95,7 +95,7 @@ export async function acvm(
     initialWitness,
     async (name: string, args: ForeignCallInput[]) => {
       try {
-        logger(`Oracle callback ${name}`);
+        logger.verbose(`Oracle callback ${name}`);
         const oracleFunction = callback[name as ORACLE_NAMES];
         if (!oracleFunction) {
           throw new Error(`Oracle callback ${name} not found`);

package/src/acvm/oracle/index.ts

@@ -1,6 +1,5 @@
 import { type Oracle } from './oracle.js';
 
-export * from './debug.js';
 export * from './oracle.js';
 export * from './typed_oracle.js';
 

package/src/acvm/oracle/oracle.ts

@@ -1,5 +1,5 @@
 import { MerkleTreeId, UnencryptedL2Log } from '@aztec/circuit-types';
-import { RETURN_VALUES_LENGTH } from '@aztec/circuits.js';
+import { RETURN_VALUES_LENGTH, acvmFieldMessageToString, oracleDebugCallToFormattedStr } from '@aztec/circuits.js';
 import { EventSelector, FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -9,7 +9,6 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { type ACVMField } from '../acvm_types.js';
 import { frToBoolean, frToNumber, fromACVMField } from '../deserialize.js';
 import { toACVMField, toAcvmEnqueuePublicFunctionResult } from '../serialize.js';
-import { acvmFieldMessageToString, oracleDebugCallToFormattedStr } from './debug.js';
 import { type TypedOracle } from './typed_oracle.js';
 
 /**
@@ -305,12 +304,12 @@ export class Oracle {
   }
 
   debugLog(...args: ACVMField[][]): ACVMField {
-    this.log(oracleDebugCallToFormattedStr(args));
+    this.log.verbose(oracleDebugCallToFormattedStr(args));
     return toACVMField(0);
   }
 
   debugLogWithPrefix(arg0: ACVMField[], ...args: ACVMField[][]): ACVMField {
-    this.log(`${acvmFieldMessageToString(arg0)}: ${oracleDebugCallToFormattedStr(args)}`);
+    this.log.verbose(`${acvmFieldMessageToString(arg0)}: ${oracleDebugCallToFormattedStr(args)}`);
     return toACVMField(0);
   }
 

package/src/avm/avm_context.ts

@@ -2,6 +2,7 @@ import { type AztecAddress, FunctionSelector } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type AvmExecutionEnvironment } from './avm_execution_environment.js';
+import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
 import { type AvmPersistableStateManager } from './journal/journal.js';
 
@@ -33,47 +34,24 @@ export class AvmContext {
    *
    * @param address - The contract instance to initialize a context for
    * @param calldata - Data/arguments for nested call
+   * @param allocatedGas - Gas allocated for the nested call
+   * @param callType - Type of call (CALL or STATICCALL)
    * @returns new AvmContext instance
    */
   public createNestedContractCallContext(
     address: AztecAddress,
     calldata: Fr[],
+    allocatedGas: Gas,
+    callType: 'CALL' | 'STATICCALL',
     temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
   ): AvmContext {
-    const newExecutionEnvironment = this.environment.deriveEnvironmentForNestedCall(
-      address,
-      calldata,
-      temporaryFunctionSelector,
-    );
+    const deriveFn =
+      callType === 'CALL'
+        ? this.environment.deriveEnvironmentForNestedCall
+        : this.environment.deriveEnvironmentForNestedStaticCall;
+    const newExecutionEnvironment = deriveFn.call(this.environment, address, calldata, temporaryFunctionSelector);
     const forkedWorldState = this.persistableState.fork();
-    const machineState = AvmMachineState.fromState(this.machineState);
-    return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
-  }
-
-  /**
-   * Prepare a new AVM context that will be ready for an external/nested static call
-   * - Fork the world state journal
-   * - Derive a machine state from the current state
-   *   - E.g., gas metering is preserved but pc is reset
-   * - Derive an execution environment from the caller/parent
-   *   - Alter both address and storageAddress
-   *
-   * @param address - The contract instance to initialize a context for
-   * @param calldata - Data/arguments for nested call
-   * @returns new AvmContext instance
-   */
-  public createNestedContractStaticCallContext(
-    address: AztecAddress,
-    calldata: Fr[],
-    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
-  ): AvmContext {
-    const newExecutionEnvironment = this.environment.deriveEnvironmentForNestedStaticCall(
-      address,
-      calldata,
-      temporaryFunctionSelector,
-    );
-    const forkedWorldState = this.persistableState.fork();
-    const machineState = AvmMachineState.fromState(this.machineState);
+    const machineState = AvmMachineState.fromState(gasToGasLeft(allocatedGas));
     return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
   }
 }

package/src/avm/avm_execution_environment.ts

@@ -1,4 +1,4 @@
-import { FunctionSelector, type GlobalVariables } from '@aztec/circuits.js';
+import { FunctionSelector, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type EthAddress } from '@aztec/foundation/eth-address';
@@ -22,29 +22,18 @@ export class AvmContextInputs {
 export class AvmExecutionEnvironment {
   constructor(
     public readonly address: AztecAddress,
-
     public readonly storageAddress: AztecAddress,
-
     public readonly origin: AztecAddress,
-
     public readonly sender: AztecAddress,
-
     public readonly portal: EthAddress,
-
     public readonly feePerL1Gas: Fr,
-
     public readonly feePerL2Gas: Fr,
-
     public readonly feePerDaGas: Fr,
-
     public readonly contractCallDepth: Fr,
-
+    public readonly header: Header,
     public readonly globals: GlobalVariables,
-
     public readonly isStaticCall: boolean,
-
     public readonly isDelegateCall: boolean,
-
     public readonly calldata: Fr[],
 
     // Function selector is temporary since eventually public contract bytecode will be one blob
@@ -59,20 +48,21 @@ export class AvmExecutionEnvironment {
   }
 
   public deriveEnvironmentForNestedCall(
-    address: AztecAddress,
+    targetAddress: AztecAddress,
     calldata: Fr[],
     temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
   ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      address,
-      /*storageAddress=*/ address,
+      targetAddress,
+      /*storageAddress=*/ targetAddress,
       this.origin,
-      this.sender,
+      this.address,
       this.portal,
       this.feePerL1Gas,
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       this.isDelegateCall,
@@ -96,6 +86,7 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       /*isStaticCall=*/ true,
       this.isDelegateCall,
@@ -119,6 +110,7 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       /*isDelegateCall=*/ true,

package/src/avm/{avm_gas_cost.ts → avm_gas.ts}

@@ -1,20 +1,49 @@
 import { TypeTag } from './avm_memory_types.js';
+import { InstructionExecutionError } from './errors.js';
+import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 import { Opcode } from './serialization/instruction_serialization.js';
 
-/** Gas cost in L1, L2, and DA for a given instruction. */
-export type GasCost = {
+/** Gas counters in L1, L2, and DA. */
+export type Gas = {
   l1Gas: number;
   l2Gas: number;
   daGas: number;
 };
 
+/** Maps a Gas struct to gasLeft properties. */
+export function gasToGasLeft(gas: Gas) {
+  return { l1GasLeft: gas.l1Gas, l2GasLeft: gas.l2Gas, daGasLeft: gas.daGas };
+}
+
+/** Maps gasLeft properties to a gas struct. */
+export function gasLeftToGas(gasLeft: { l1GasLeft: number; l2GasLeft: number; daGasLeft: number }) {
+  return { l1Gas: gasLeft.l1GasLeft, l2Gas: gasLeft.l2GasLeft, daGas: gasLeft.daGasLeft };
+}
+
 /** Creates a new instance with all values set to zero except the ones set. */
-export function makeGasCost(gasCost: Partial<GasCost>) {
-  return { ...EmptyGasCost, ...gasCost };
+export function makeGas(gasCost: Partial<Gas>) {
+  return { ...EmptyGas, ...gasCost };
+}
+
+/** Sums together multiple instances of Gas. */
+export function sumGas(...gases: Partial<Gas>[]) {
+  return gases.reduce(
+    (acc: Gas, gas) => ({
+      l1Gas: acc.l1Gas + (gas.l1Gas ?? 0),
+      l2Gas: acc.l2Gas + (gas.l2Gas ?? 0),
+      daGas: acc.daGas + (gas.daGas ?? 0),
+    }),
+    EmptyGas,
+  );
+}
+
+/** Multiplies a gas instance by a scalar. */
+export function mulGas(gas: Partial<Gas>, scalar: number) {
+  return { l1Gas: (gas.l1Gas ?? 0) * scalar, l2Gas: (gas.l2Gas ?? 0) * scalar, daGas: (gas.daGas ?? 0) * scalar };
 }
 
-/** Gas cost of zero across all gas dimensions. */
-export const EmptyGasCost = {
+/** Zero gas across all gas dimensions. */
+export const EmptyGas: Gas = {
   l1Gas: 0,
   l2Gas: 0,
   daGas: 0,
@@ -29,12 +58,12 @@ export const DynamicGasCost = Symbol('DynamicGasCost');
 /** Temporary default gas cost. We should eventually remove all usage of this variable in favor of actual gas for each opcode. */
 const TemporaryDefaultGasCost = { l1Gas: 0, l2Gas: 10, daGas: 0 };
 
-/** Gas costs for each instruction. */
-export const GasCosts = {
-  [Opcode.ADD]: DynamicGasCost,
-  [Opcode.SUB]: DynamicGasCost,
-  [Opcode.MUL]: DynamicGasCost,
-  [Opcode.DIV]: DynamicGasCost,
+/** Base gas costs for each instruction. Additional gas cost may be added on top due to memory or storage accesses, etc. */
+export const GasCosts: Record<Opcode, Gas | typeof DynamicGasCost> = {
+  [Opcode.ADD]: TemporaryDefaultGasCost,
+  [Opcode.SUB]: TemporaryDefaultGasCost,
+  [Opcode.MUL]: TemporaryDefaultGasCost,
+  [Opcode.DIV]: TemporaryDefaultGasCost,
   [Opcode.FDIV]: TemporaryDefaultGasCost,
   [Opcode.EQ]: TemporaryDefaultGasCost,
   [Opcode.LT]: TemporaryDefaultGasCost,
@@ -64,7 +93,7 @@ export const GasCosts = {
   [Opcode.BLOCKL1GASLIMIT]: TemporaryDefaultGasCost,
   [Opcode.BLOCKL2GASLIMIT]: TemporaryDefaultGasCost,
   [Opcode.BLOCKDAGASLIMIT]: TemporaryDefaultGasCost,
-  [Opcode.CALLDATACOPY]: DynamicGasCost,
+  [Opcode.CALLDATACOPY]: TemporaryDefaultGasCost,
   // Gas
   [Opcode.L1GASLEFT]: TemporaryDefaultGasCost,
   [Opcode.L2GASLEFT]: TemporaryDefaultGasCost,
@@ -75,7 +104,7 @@ export const GasCosts = {
   [Opcode.INTERNALCALL]: TemporaryDefaultGasCost,
   [Opcode.INTERNALRETURN]: TemporaryDefaultGasCost,
   // Memory
-  [Opcode.SET]: DynamicGasCost,
+  [Opcode.SET]: TemporaryDefaultGasCost,
   [Opcode.MOV]: TemporaryDefaultGasCost,
   [Opcode.CMOV]: TemporaryDefaultGasCost,
   // World state
@@ -89,6 +118,7 @@ export const GasCosts = {
   [Opcode.HEADERMEMBER]: TemporaryDefaultGasCost,
   [Opcode.EMITUNENCRYPTEDLOG]: TemporaryDefaultGasCost,
   [Opcode.SENDL2TOL1MSG]: TemporaryDefaultGasCost,
+  [Opcode.GETCONTRACTINSTANCE]: TemporaryDefaultGasCost,
   // External calls
   [Opcode.CALL]: TemporaryDefaultGasCost,
   [Opcode.STATICCALL]: TemporaryDefaultGasCost,
@@ -100,18 +130,42 @@ export const GasCosts = {
   [Opcode.POSEIDON]: TemporaryDefaultGasCost,
   [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
   [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
-} as const;
+};
+
+/** Returns the fixed base gas cost for a given opcode, or throws if set to dynamic. */
+export function getBaseGasCost(opcode: Opcode): Gas {
+  const cost = GasCosts[opcode];
+  if (cost === DynamicGasCost) {
+    throw new Error(`Opcode ${Opcode[opcode]} has dynamic gas cost`);
+  }
+  return cost;
+}
+
+/** 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;
+  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;
+  return makeGas({ l2Gas: l2MemoryGasCost });
+}
 
 /** Constants used in base cost calculations. */
 export const GasCostConstants = {
-  SET_COST_PER_BYTE: 100,
-  CALLDATACOPY_COST_PER_BYTE: 10,
-  ARITHMETIC_COST_PER_BYTE: 10,
-  ARITHMETIC_COST_PER_INDIRECT_ACCESS: 5,
+  MEMORY_READ: 10,
+  MEMORY_INDIRECT_READ_PENALTY: 10,
+  MEMORY_WRITE: 100,
 };
 
+/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
+export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
+  return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));
+}
+
 /** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
-export function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT8:
       return 1;
@@ -127,6 +181,6 @@ export function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
       return 32;
     case TypeTag.INVALID:
     case TypeTag.UNINITIALIZED:
-      throw new Error(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
+      throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }
 }

package/src/avm/avm_machine_state.ts

@@ -1,6 +1,6 @@
 import { type Fr } from '@aztec/circuits.js';
 
-import { type GasCost, GasDimensions } from './avm_gas_cost.js';
+import { type Gas, GasDimensions } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
 import { OutOfGasError } from './errors.js';
@@ -59,7 +59,7 @@ export class AvmMachineState {
    * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
    * an exceptional halt by throwing an OutOfGasError.
    */
-  public consumeGas(gasCost: Partial<GasCost>) {
+  public consumeGas(gasCost: Partial<Gas>) {
     // Assert there is enough gas on every dimension.
     const outOfGasDimensions = GasDimensions.filter(
       dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
@@ -76,6 +76,13 @@ export class AvmMachineState {
     }
   }
 
+  /** Increases the gas left by the amounts specified. */
+  public refundGas(gasRefund: Partial<Gas>) {
+    for (const dimension of GasDimensions) {
+      this[`${dimension}Left`] += gasRefund[dimension] ?? 0;
+    }
+  }
+
   /**
    * Most instructions just increment PC before they complete
    */