@aztec/simulator 0.26.5 → 0.27.0

package/dest/public/executor.js

@@ -1,5 +1,9 @@
+import { FunctionL2Logs } from '@aztec/circuit-types';
 import { PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
 import { Oracle, acvm, extractCallStack, extractReturnWitness } from '../acvm/index.js';
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
@@ -7,30 +11,70 @@ import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { temporaryConvertAvmResults, temporaryCreateAvmExecutionEnvironment, } from '../avm/temporary_executor_migration.js';
+import { AcirSimulator } from '../client/simulator.js';
 import { ExecutionError, createSimulationError } from '../common/errors.js';
 import { SideEffectCounter } from '../common/index.js';
 import { PackedArgsCache } from '../common/packed_args_cache.js';
-import { AcirSimulator } from '../index.js';
 import { checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
 /**
  * Execute a public function and return the execution result.
  */
-export async function executePublicFunction(context, acir, log = createDebugLogger('aztec:simulator:public_execution')) {
+export async function executePublicFunction(context, acir, nested, log = createDebugLogger('aztec:simulator:public_execution')) {
     const execution = context.execution;
     const { contractAddress, functionData } = execution;
     const selector = functionData.selector;
     log(`Executing public external function ${contractAddress.toString()}:${selector}`);
     const initialWitness = context.getInitialWitness();
     const acvmCallback = new Oracle(context);
-    const { partialWitness } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch((err) => {
-        throw new ExecutionError(err.message, {
+    const { partialWitness, reverted, revertReason } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback)
+        .then(result => ({
+        partialWitness: result.partialWitness,
+        reverted: false,
+        revertReason: undefined,
+    }))
+        .catch((err) => {
+        const ee = new ExecutionError(err.message, {
             contractAddress,
             functionSelector: selector,
         }, extractCallStack(err), { cause: err });
+        if (nested) {
+            // If we're nested, throw the error so the parent can handle it
+            throw ee;
+        }
+        else {
+            return {
+                partialWitness: undefined,
+                reverted: true,
+                revertReason: createSimulationError(ee),
+            };
+        }
     });
+    if (reverted) {
+        if (!revertReason) {
+            throw new Error('Reverted but no revert reason');
+        }
+        return {
+            execution,
+            returnValues: [],
+            newNoteHashes: [],
+            newL2ToL1Messages: [],
+            newNullifiers: [],
+            nullifierReadRequests: [],
+            contractStorageReads: [],
+            contractStorageUpdateRequests: [],
+            nestedExecutions: [],
+            unencryptedLogs: FunctionL2Logs.empty(),
+            reverted,
+            revertReason,
+        };
+    }
+    if (!partialWitness) {
+        throw new Error('No partial witness returned from ACVM');
+    }
     const returnWitness = extractReturnWitness(acir, partialWitness);
-    const { returnValues, newL2ToL1Msgs, newNoteHashes: newNoteHashesPadded, newNullifiers: newNullifiersPadded, } = PublicCircuitPublicInputs.fromFields(returnWitness);
+    const { returnValues, nullifierReadRequests: nullifierReadRequestsPadded, newL2ToL1Msgs, newNoteHashes: newNoteHashesPadded, newNullifiers: newNullifiersPadded, } = PublicCircuitPublicInputs.fromFields(returnWitness);
+    const nullifierReadRequests = nullifierReadRequestsPadded.filter(v => !v.isEmpty());
     const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isEmpty());
     const newNoteHashes = newNoteHashesPadded.filter(v => !v.isEmpty());
     const newNullifiers = newNullifiersPadded.filter(v => !v.isEmpty());
@@ -48,11 +92,14 @@ export async function executePublicFunction(context, acir, log = createDebugLogg
         newNoteHashes,
         newL2ToL1Messages,
         newNullifiers,
+        nullifierReadRequests,
         contractStorageReads,
         contractStorageUpdateRequests,
         returnValues,
         nestedExecutions,
         unencryptedLogs,
+        reverted: false,
+        revertReason: undefined,
     };
 }
 /**
@@ -82,13 +129,7 @@ export class PublicExecutor {
         const packedArgs = PackedArgsCache.create([]);
         const sideEffectCounter = new SideEffectCounter();
         const context = new PublicExecutionContext(execution, this.header, globalVariables, packedArgs, sideEffectCounter, this.stateDb, this.contractsDb, this.commitmentsDb);
-        let executionResult;
-        try {
-            executionResult = await executePublicFunction(context, acir);
-        }
-        catch (err) {
-            throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during public execution'));
-        }
+        const executionResult = await executePublicFunction(context, acir, false /** nested */);
         if (executionResult.execution.callContext.isStaticCall) {
             checkValidStaticCall(executionResult.newNoteHashes, executionResult.newNullifiers, executionResult.contractStorageUpdateRequests, executionResult.newL2ToL1Messages, executionResult.unencryptedLogs);
         }
@@ -113,5 +154,88 @@ export class PublicExecutor {
         const newWorldState = context.persistableState.flush();
         return temporaryConvertAvmResults(execution, newWorldState, result);
     }
+    /**
+     * These functions are currently housed in the temporary executor as it relies on access to
+     * oracles like the contractsDB and this is the least intrusive way to achieve this.
+     * When we remove this executor(tracking issue #4792) and have an interface that is compatible with the kernel circuits,
+     * this will be moved to sequencer-client/prover.
+     */
+    /**
+     * Generates a proof for an associated avm execution. This is currently only used for testing purposes,
+     * as proof generation is not fully complete in the AVM yet.
+     * @param execution - The execution to run.
+     * @returns An AVM proof and the verification key.
+     */
+    async getAvmProof(avmExecution) {
+        // The paths for the barretenberg binary and the write path are hardcoded for now.
+        // We additionally need the path to a valid crs for proof generation.
+        // const bbPath = '../../barretenberg/cpp';
+        const bbPath = path.resolve('../../barretenberg/cpp');
+        const artifactsPath = path.resolve('target');
+        // Create the directory if it does not exist
+        await fs.mkdir(artifactsPath, { recursive: true });
+        const calldataPath = path.join(artifactsPath, 'calldata.bin');
+        const bytecodePath = path.join(artifactsPath, 'avm_bytecode.bin');
+        const proofPath = path.join(artifactsPath, 'proof');
+        const { args, functionData, contractAddress } = avmExecution;
+        const bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
+        // Write call data and bytecode to files.
+        await Promise.all([
+            fs.writeFile(calldataPath, args.map(c => c.toBuffer())),
+            fs.writeFile(bytecodePath, bytecode),
+        ]);
+        const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), [
+            'avm_prove',
+            '-b',
+            bytecodePath,
+            '-d',
+            calldataPath,
+            '-c',
+            path.join(bbPath, 'srs_db', 'ignition'),
+            '-o',
+            proofPath,
+        ]);
+        // The binary writes the proof and the verification key to the write path.
+        return new Promise((resolve, reject) => {
+            bbBinary.on('close', () => {
+                resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
+            });
+            // Catch and propagate errors from spawning
+            bbBinary.on('error', err => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Verifies an AVM proof. This function is currently only used for testing purposes, as verification
+     * is not fully complete in the AVM yet.
+     * @param vk - The verification key to use.
+     * @param proof - The proof to verify.
+     * @returns True if the proof is valid, false otherwise.
+     */
+    async verifyAvmProof(vk, proof) {
+        // The relative paths for the barretenberg binary and the write path are hardcoded for now.
+        const bbPath = path.resolve('../../barretenberg/cpp');
+        const artifactsPath = path.resolve('./target');
+        const vkPath = path.join(artifactsPath, 'vk');
+        const proofPath = path.join(artifactsPath, 'proof');
+        // Write the verification key and the proof to files.
+        await Promise.all([fs.writeFile(vkPath, vk), fs.writeFile(proofPath, proof)]);
+        const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), ['avm_verify', '-p', proofPath]);
+        // The binary prints to stdout 1 if the proof is valid and 0 if it is not.
+        return new Promise((resolve, reject) => {
+            let result = Buffer.alloc(0);
+            bbBinary.stdout.on('data', data => {
+                result += data;
+            });
+            bbBinary.on('close', () => {
+                resolve(result.toString() === '1');
+            });
+            // Catch and propagate errors from spawning
+            bbBinary.on('error', err => {
+                reject(err);
+            });
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../src/public/executor.ts"],"names":[],"mappings":"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"}

package/dest/public/public_execution_context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public_execution_context.d.ts","sourceRoot":"","sources":["../../src/public/public_execution_context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACpG,OAAO,EAA6B,gBAAgB,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,WAAW,EAAiB,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAwB,MAAM,gBAAgB,CAAC;AAI9F;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;IAMnD;;OAEG;aACa,SAAS,EAAE,eAAe;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,GAAG;IAhBb,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,eAAe,CAA0B;;IAG/C;;OAEG;IACa,SAAS,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,eAAe,EAAE,eAAe,EAChC,iBAAiB,EAAE,iBAAiB,EACpC,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,iBAAiB,EAC9B,aAAa,EAAE,aAAa,EACrC,GAAG,8CAAgE;IAM7E;;;;;;;;OAQG;IACI,iBAAiB,CAAC,iBAAiB,SAAI;IAO9C;;OAEG;IACI,mBAAmB;IAI1B;;OAEG;IACI,kBAAkB;IAIzB;;OAEG;IACI,oBAAoB;;;;IAK3B;;;OAGG;IACI,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAI7C;;;;OAIG;IACU,0BAA0B,CAAC,QAAQ,EAAE,EAAE;IAIpD;;;OAGG;IACI,kBAAkB,CAAC,GAAG,EAAE,gBAAgB;IAM/C;;;;;OAKG;IACU,wBAAwB,CAAC,eAAe,EAAE,YAAY;IAInE;;;;OAIG;IACU,WAAW,CAAC,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,MAAM;IAYvE;;;;OAIG;IACU,YAAY,CAAC,gBAAgB,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IAc5D;;;;;;OAMG;IACU,kBAAkB,CAC7B,qBAAqB,EAAE,YAAY,EACnC,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,EAAE,EAAE,EACZ,YAAY,EAAE,OAAO,EACrB,cAAc,EAAE,OAAO;IAoEZ,6BAA6B,CACxC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,EAAE,GACZ,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC;CAMnD"}
+{"version":3,"file":"public_execution_context.d.ts","sourceRoot":"","sources":["../../src/public/public_execution_context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACpG,OAAO,EAA6B,gBAAgB,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,WAAW,EAAiB,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAwB,MAAM,gBAAgB,CAAC;AAI9F;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;IAMnD;;OAEG;aACa,SAAS,EAAE,eAAe;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,GAAG;IAhBb,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,eAAe,CAA0B;;IAG/C;;OAEG;IACa,SAAS,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,eAAe,EAAE,eAAe,EAChC,iBAAiB,EAAE,iBAAiB,EACpC,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,iBAAiB,EAC9B,aAAa,EAAE,aAAa,EACrC,GAAG,8CAAgE;IAM7E;;;;;;;;OAQG;IACI,iBAAiB,CAAC,iBAAiB,SAAI;IAO9C;;OAEG;IACI,mBAAmB;IAI1B;;OAEG;IACI,kBAAkB;IAIzB;;OAEG;IACI,oBAAoB;;;;IAK3B;;;OAGG;IACI,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAI7C;;;;OAIG;IACU,0BAA0B,CAAC,QAAQ,EAAE,EAAE;IAIpD;;;OAGG;IACI,kBAAkB,CAAC,GAAG,EAAE,gBAAgB;IAM/C;;;;;OAKG;IACU,wBAAwB,CAAC,eAAe,EAAE,YAAY;IAInE;;;;OAIG;IACU,WAAW,CAAC,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,MAAM;IAYvE;;;;OAIG;IACU,YAAY,CAAC,gBAAgB,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IAc5D;;;;;;OAMG;IACU,kBAAkB,CAC7B,qBAAqB,EAAE,YAAY,EACnC,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,EAAE,EAAE,EACZ,YAAY,EAAE,OAAO,EACrB,cAAc,EAAE,OAAO;IAmEZ,6BAA6B,CACxC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,EAAE,GACZ,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC;CAMnD"}

package/dest/public/public_execution_context.js

@@ -156,7 +156,6 @@ export class PublicExecutionContext extends TypedOracle {
             storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
             portalContractAddress: portalAddress,
             functionSelector,
-            isContractDeployment: false,
             isDelegateCall,
             isStaticCall,
             startSideEffectCounter: 0, // TODO use counters in public execution
@@ -168,7 +167,7 @@ export class PublicExecutionContext extends TypedOracle {
             callContext,
         };
         const context = new PublicExecutionContext(nestedExecution, this.header, this.globalVariables, this.packedArgsCache, this.sideEffectCounter, this.stateDb, this.contractsDb, this.commitmentsDb, this.log);
-        const childExecutionResult = await executePublicFunction(context, acir);
+        const childExecutionResult = await executePublicFunction(context, acir, true /** nested */);
         if (isStaticCall) {
             checkValidStaticCall(childExecutionResult.newNoteHashes, childExecutionResult.newNullifiers, childExecutionResult.contractStorageUpdateRequests, childExecutionResult.newL2ToL1Messages, childExecutionResult.unencryptedLogs);
         }
@@ -183,4 +182,4 @@ export class PublicExecutionContext extends TypedOracle {
         return await this.commitmentsDb.getNullifierMembershipWitnessAtLatestBlock(nullifier);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_execution_context.js","sourceRoot":"","sources":["../../src/public/public_execution_context.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_execution_context.js","sourceRoot":"","sources":["../../src/public/public_execution_context.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.26.5",
+  "version": "0.27.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -30,10 +30,10 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.26.5",
-    "@aztec/circuits.js": "0.26.5",
-    "@aztec/foundation": "0.26.5",
-    "@aztec/types": "0.26.5",
+    "@aztec/circuit-types": "0.27.0",
+    "@aztec/circuits.js": "0.27.0",
+    "@aztec/foundation": "0.27.0",
+    "@aztec/types": "0.27.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",

package/src/acvm/acvm.ts

@@ -110,7 +110,7 @@ export async function acvm(
         } else {
           typedError = new Error(`Error in oracle callback ${err}`);
         }
-        logger.error(`Error in oracle callback ${name}`);
+        logger.error(`Error in oracle callback ${name}: ${typedError.message}`);
         throw typedError;
       }
     },

package/src/acvm/serialize.ts

@@ -1,4 +1,4 @@
-import { PublicCallRequest } from '@aztec/circuits.js';
+import { ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH, PublicCallRequest } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -53,12 +53,18 @@ export function toACVMField(
  * TODO(#4380): Nuke this and replace it with PublicCallRequest.toFields()
  */
 export function toAcvmEnqueuePublicFunctionResult(item: PublicCallRequest): ACVMField[] {
-  return [
+  const fields = [
     item.contractAddress.toField(),
     ...item.functionData.toFields(),
     ...item.callContext.toFields(),
     item.getArgsHash(),
-  ].map(toACVMField);
+  ];
+  if (fields.length !== ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH) {
+    throw new Error(
+      `Invalid length for EnqueuePublicFunctionResult (got ${fields.length} expected ${ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH})`,
+    );
+  }
+  return fields.map(toACVMField);
 }
 
 /**

package/src/avm/avm_context.ts

@@ -1,4 +1,4 @@
-import { AztecAddress } from '@aztec/circuits.js';
+import { AztecAddress, FunctionSelector } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
@@ -35,8 +35,16 @@ export class AvmContext {
    * @param calldata - Data/arguments for nested call
    * @returns new AvmContext instance
    */
-  public createNestedContractCallContext(address: AztecAddress, calldata: Fr[]): AvmContext {
-    const newExecutionEnvironment = this.environment.deriveEnvironmentForNestedCall(address, calldata);
+  public createNestedContractCallContext(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmContext {
+    const newExecutionEnvironment = this.environment.deriveEnvironmentForNestedCall(
+      address,
+      calldata,
+      temporaryFunctionSelector,
+    );
     const forkedWorldState = this.persistableState.fork();
     const machineState = AvmMachineState.fromState(this.machineState);
     return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
@@ -54,8 +62,16 @@ export class AvmContext {
    * @param calldata - Data/arguments for nested call
    * @returns new AvmContext instance
    */
-  public createNestedContractStaticCallContext(address: AztecAddress, calldata: Fr[]): AvmContext {
-    const newExecutionEnvironment = this.environment.deriveEnvironmentForNestedStaticCall(address, calldata);
+  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);
     return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);

package/src/avm/avm_execution_environment.ts

@@ -36,12 +36,19 @@ export class AvmExecutionEnvironment {
 
     public readonly calldata: Fr[],
 
+    // Function selector is temporary since eventually public contract bytecode will be one blob
+    // containing all functions, and function selector will become an application-level mechanism
+    // (e.g. first few bytes of calldata + compiler-generated jump table)
     public readonly temporaryFunctionSelector: FunctionSelector,
   ) {}
 
-  public deriveEnvironmentForNestedCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       /*storageAddress=*/ address,
       this.origin,
       this.sender,
@@ -53,14 +60,18 @@ export class AvmExecutionEnvironment {
       this.globals,
       this.isStaticCall,
       this.isDelegateCall,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 
-  public deriveEnvironmentForNestedStaticCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedStaticCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       /*storageAddress=*/ address,
       this.origin,
       this.sender,
@@ -72,14 +83,18 @@ export class AvmExecutionEnvironment {
       this.globals,
       /*isStaticCall=*/ true,
       this.isDelegateCall,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 
-  public newDelegateCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public newDelegateCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       this.storageAddress,
       this.origin,
       this.sender,
@@ -91,8 +106,8 @@ export class AvmExecutionEnvironment {
       this.globals,
       this.isStaticCall,
       /*isDelegateCall=*/ true,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 }

package/src/avm/avm_memory_types.ts

@@ -1,5 +1,6 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
@@ -28,6 +29,10 @@ export abstract class MemoryValue {
   public toFr(): Fr {
     return new Fr(this.toBigInt());
   }
+
+  public toString(): string {
+    return `${this.constructor.name}(0x${this.toBigInt().toString(16)})`;
+  }
 }
 
 /** IntegralValue gathers the common operations for all integral memory types. */
@@ -189,6 +194,8 @@ export enum TypeTag {
 
 // TODO: Consider automatic conversion when getting undefined values.
 export class TaggedMemory {
+  static readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:memory');
+
   // FIXME: memory should be 2^32, but TS doesn't allow for arrays that big.
   static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 2n);
   private _mem: MemoryValue[];
@@ -200,25 +207,29 @@ export class TaggedMemory {
 
   public get(offset: number): MemoryValue {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    return this.getAs<MemoryValue>(offset);
+    const value = this.getAs<MemoryValue>(offset);
+    return value;
   }
 
   public getAs<T>(offset: number): T {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
+    TaggedMemory.log(`get(${offset}) = ${word}`);
     return word as T;
   }
 
   public getSlice(offset: number, size: number): MemoryValue[] {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
-    return this._mem.slice(offset, offset + size);
+    const value = this._mem.slice(offset, offset + size);
+    TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    return value;
   }
 
   public getSliceAs<T>(offset: number, size: number): T[] {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
-    return this._mem.slice(offset, offset + size) as T[];
+    return this.getSlice(offset, size) as T[];
   }
 
   public getSliceTags(offset: number, size: number): TypeTag[] {
@@ -230,6 +241,7 @@ export class TaggedMemory {
   public set(offset: number, v: MemoryValue) {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem[offset] = v;
+    TaggedMemory.log(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
@@ -240,6 +252,7 @@ export class TaggedMemory {
       this._mem.length = offset + vs.length;
     }
     this._mem.splice(offset, vs.length, ...vs);
+    TaggedMemory.log(`setSlice(${offset}, ${vs})`);
   }
 
   public getTag(offset: number): TypeTag {
@@ -255,6 +268,12 @@ export class TaggedMemory {
     }
   }
 
+  public checkIsValidMemoryOffsetTag(offset: number) {
+    if (this.getTag(offset) > TypeTag.UINT64) {
+      throw TagCheckError.forOffset(offset, TypeTag[this.getTag(offset)], 'UINT64');
+    }
+  }
+
   public static checkIsIntegralTag(tag: TypeTag) {
     if (![TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)) {
       throw TagCheckError.forTag(TypeTag[tag], 'integral');
@@ -321,4 +340,24 @@ export class TaggedMemory {
         throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
     }
   }
+
+  // Does not truncate. Type constructor will check that it fits.
+  public static buildFromTagOrDie(v: bigint | number, tag: TypeTag): MemoryValue {
+    switch (tag) {
+      case TypeTag.UINT8:
+        return new Uint8(v);
+      case TypeTag.UINT16:
+        return new Uint16(v);
+      case TypeTag.UINT32:
+        return new Uint32(v);
+      case TypeTag.UINT64:
+        return new Uint64(v);
+      case TypeTag.UINT128:
+        return new Uint128(v);
+      case TypeTag.FIELD:
+        return new Field(v);
+      default:
+        throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
+    }
+  }
 }

package/src/avm/avm_simulator.ts

@@ -9,9 +9,13 @@ import type { Instruction } from './opcodes/index.js';
 import { decodeFromBytecode } from './serialization/bytecode_serialization.js';
 
 export class AvmSimulator {
-  private log: DebugLogger = createDebugLogger('aztec:avm_simulator');
+  private log: DebugLogger;
 
-  constructor(private context: AvmContext) {}
+  constructor(private context: AvmContext) {
+    this.log = createDebugLogger(
+      `aztec:avm_simulator:core(f:${context.environment.temporaryFunctionSelector.toString()})`,
+    );
+  }
 
   /**
    * Fetch the bytecode and execute it in the current context.
@@ -52,7 +56,10 @@ export class AvmSimulator {
       // continuing until the machine state signifies a halt
       while (!this.context.machineState.halted) {
         const instruction = instructions[this.context.machineState.pc];
-        assert(!!instruction); // This should never happen
+        assert(
+          !!instruction,
+          'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
+        );
 
         this.log.debug(`@${this.context.machineState.pc} ${instruction.toString()}`);
         // Execute the instruction.

package/src/avm/opcodes/addressing_mode.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert';
 
-import { TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { TaggedMemory } from '../avm_memory_types.js';
 
 export enum AddressingMode {
   DIRECT,
@@ -51,7 +51,8 @@ export class Addressing {
     for (const [i, offset] of offsets.entries()) {
       switch (this.modePerOperand[i]) {
         case AddressingMode.INDIRECT:
-          mem.checkTag(TypeTag.UINT32, offset);
+          // NOTE(reviewer): less than equal is a deviation from the spec - i dont see why this shouldnt be possible!
+          mem.checkIsValidMemoryOffsetTag(offset);
           resolved[i] = Number(mem.get(offset).toBigInt());
           break;
         case AddressingMode.DIRECT: