@aztec/simulator 0.60.0 → 0.62.0

package/dest/test/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,aAAa,EAAW,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAc,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAI5E;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,aACnB,MAAM,mBACC,EAAE,EAAE,kBACL,YAAY,UACpB,EAAE,kBASX,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,aAAa,EAAW,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAc,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAIvE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,aACnB,MAAM,mBACC,EAAE,EAAE,kBACL,YAAY,UACpB,EAAE,YACA,EAAE,GAAG,MAAM,kBAetB,CAAC"}

package/dest/test/utils.js

@@ -1,5 +1,5 @@
 import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/circuit-types';
-import { EthAddress } from '@aztec/circuits.js';
+import { EthAddress, Fr } from '@aztec/circuits.js';
 import { computeSecretHash } from '@aztec/circuits.js/hash';
 import { sha256ToField } from '@aztec/foundation/crypto';
 /**
@@ -10,11 +10,11 @@ import { sha256ToField } from '@aztec/foundation/crypto';
  * @param secret - The secret to unlock the message.
  * @returns The L1 to L2 message.
  */
-export const buildL1ToL2Message = (selector, contentPreimage, targetContract, secret) => {
+export const buildL1ToL2Message = (selector, contentPreimage, targetContract, secret, msgIndex) => {
     // Write the selector into a buffer.
     const selectorBuf = Buffer.from(selector, 'hex');
     const content = sha256ToField([selectorBuf, ...contentPreimage]);
     const secretHash = computeSecretHash(secret);
-    return new L1ToL2Message(new L1Actor(EthAddress.random(), 1), new L2Actor(targetContract, 1), content, secretHash);
+    return new L1ToL2Message(new L1Actor(EthAddress.random(), 1), new L2Actor(targetContract, 1), content, secretHash, new Fr(msgIndex));
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxPQUFPLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEVBQXFCLFVBQVUsRUFBVyxNQUFNLG9CQUFvQixDQUFDO0FBQzVFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV6RDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsQ0FDaEMsUUFBZ0IsRUFDaEIsZUFBcUIsRUFDckIsY0FBNEIsRUFDNUIsTUFBVSxFQUNWLEVBQUU7SUFDRixvQ0FBb0M7SUFDcEMsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFFakQsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsZUFBZSxDQUFDLENBQUMsQ0FBQztJQUNqRSxNQUFNLFVBQVUsR0FBRyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUU3QyxPQUFPLElBQUksYUFBYSxDQUFDLElBQUksT0FBTyxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDLEVBQUUsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0FBQ3JILENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxPQUFPLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEVBQXFCLFVBQVUsRUFBRSxFQUFFLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFekQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQ2hDLFFBQWdCLEVBQ2hCLGVBQXFCLEVBQ3JCLGNBQTRCLEVBQzVCLE1BQVUsRUFDVixRQUFxQixFQUNyQixFQUFFO0lBQ0Ysb0NBQW9DO0lBQ3BDLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBRWpELE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyxDQUFDLFdBQVcsRUFBRSxHQUFHLGVBQWUsQ0FBQyxDQUFDLENBQUM7SUFDakUsTUFBTSxVQUFVLEdBQUcsaUJBQWlCLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFN0MsT0FBTyxJQUFJLGFBQWEsQ0FDdEIsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUNuQyxJQUFJLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDLEVBQzlCLE9BQU8sRUFDUCxVQUFVLEVBQ1YsSUFBSSxFQUFFLENBQUMsUUFBUSxDQUFDLENBQ2pCLENBQUM7QUFDSixDQUFDLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.60.0",
+  "version": "0.62.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -59,14 +59,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.60.0",
-    "@aztec/circuits.js": "0.60.0",
-    "@aztec/foundation": "0.60.0",
-    "@aztec/noir-protocol-circuits-types": "0.60.0",
-    "@aztec/protocol-contracts": "0.60.0",
-    "@aztec/telemetry-client": "0.60.0",
-    "@aztec/types": "0.60.0",
-    "@aztec/world-state": "0.60.0",
+    "@aztec/circuit-types": "0.62.0",
+    "@aztec/circuits.js": "0.62.0",
+    "@aztec/foundation": "0.62.0",
+    "@aztec/noir-protocol-circuits-types": "0.62.0",
+    "@aztec/protocol-contracts": "0.62.0",
+    "@aztec/telemetry-client": "0.62.0",
+    "@aztec/types": "0.62.0",
+    "@aztec/world-state": "0.62.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "@noir-lang/types": "portal:../../noir/packages/types",
     "levelup": "^5.1.1",

package/src/acvm/oracle/oracle.ts

@@ -408,4 +408,24 @@ export class Oracle {
   notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]) {
     this.typedOracle.notifySetMinRevertibleSideEffectCounter(frToNumber(fromACVMField(minRevertibleSideEffectCounter)));
   }
+
+  async getAppTaggingSecret([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
+    const taggingSecret = await this.typedOracle.getAppTaggingSecret(
+      AztecAddress.fromString(sender),
+      AztecAddress.fromString(recipient),
+    );
+    return taggingSecret.toFields().map(toACVMField);
+  }
+
+  async incrementAppTaggingSecret([sender]: ACVMField[], [recipient]: ACVMField[]) {
+    await this.typedOracle.incrementAppTaggingSecret(
+      AztecAddress.fromString(sender),
+      AztecAddress.fromString(recipient),
+    );
+  }
+
+  async getAppTaggingSecretsForSenders([recipient]: ACVMField[]): Promise<ACVMField[]> {
+    const taggingSecrets = await this.typedOracle.getAppTaggingSecretsForSenders(AztecAddress.fromString(recipient));
+    return taggingSecrets.flatMap(taggingSecret => taggingSecret.toFields().map(toACVMField));
+  }
 }

package/src/acvm/oracle/typed_oracle.ts

@@ -11,6 +11,7 @@ import {
 import {
   type ContractInstance,
   type Header,
+  type IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
 } from '@aztec/circuits.js';
@@ -252,4 +253,16 @@ export abstract class TypedOracle {
   debugLog(_message: string, _fields: Fr[]): void {
     throw new OracleMethodNotAvailableError('debugLog');
   }
+
+  getAppTaggingSecret(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret> {
+    throw new OracleMethodNotAvailableError('getAppTaggingSecret');
+  }
+
+  incrementAppTaggingSecret(_sender: AztecAddress, _recipient: AztecAddress): Promise<void> {
+    throw new OracleMethodNotAvailableError('incrementAppTaggingSecret');
+  }
+
+  getAppTaggingSecretsForSenders(_recipient: AztecAddress): Promise<IndexedTaggingSecret[]> {
+    throw new OracleMethodNotAvailableError('getAppTaggingSecretsForSenders');
+  }
 }

package/src/avm/avm_gas.ts

@@ -89,8 +89,10 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.CAST_16]: makeCost(c.AVM_CAST_BASE_L2_GAS, 0),
   [Opcode.GETENVVAR_16]: makeCost(c.AVM_GETENVVAR_BASE_L2_GAS, 0),
   [Opcode.CALLDATACOPY]: makeCost(c.AVM_CALLDATACOPY_BASE_L2_GAS, 0),
-  [Opcode.JUMP_16]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
-  [Opcode.JUMPI_16]: makeCost(c.AVM_JUMPI_BASE_L2_GAS, 0),
+  [Opcode.RETURNDATASIZE]: makeCost(c.AVM_RETURNDATASIZE_BASE_L2_GAS, 0),
+  [Opcode.RETURNDATACOPY]: makeCost(c.AVM_RETURNDATACOPY_BASE_L2_GAS, 0),
+  [Opcode.JUMP_32]: makeCost(c.AVM_JUMP_BASE_L2_GAS, 0),
+  [Opcode.JUMPI_32]: 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_8]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
@@ -122,11 +124,12 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_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.TORADIXLE]: makeCost(c.AVM_TORADIXLE_BASE_L2_GAS, 0),
+  [Opcode.TORADIXBE]: makeCost(c.AVM_TORADIXBE_BASE_L2_GAS, 0),
 };
 
 const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
+  [Opcode.RETURNDATACOPY, makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)],
   [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
   [Opcode.CALL, makeCost(c.AVM_CALL_DYN_L2_GAS, 0)],
   [Opcode.STATICCALL, makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)],
@@ -134,7 +137,7 @@ const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.MSM, makeCost(c.AVM_MSM_DYN_L2_GAS, 0)],
-  [Opcode.TORADIXLE, makeCost(c.AVM_TORADIXLE_DYN_L2_GAS, 0)],
+  [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
 ]);
 
 /** Returns the fixed base gas cost for a given opcode. */

package/src/avm/avm_machine_state.ts

@@ -21,6 +21,8 @@ export class AvmMachineState {
   public daGasLeft: number;
   /** program counter */
   public pc: number = 0;
+  /** return/revertdata of the last nested call. */
+  public nestedReturndata: Fr[] = [];
 
   /**
    * On INTERNALCALL, internal call stack is pushed to with the current pc + 1

package/src/avm/avm_simulator.ts

@@ -6,6 +6,7 @@ import { strict as assert } from 'assert';
 import { SideEffectLimitReachedError } from '../public/side_effect_errors.js';
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { type Gas } from './avm_gas.js';
 import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
@@ -17,9 +18,21 @@ import {
 import type { Instruction } from './opcodes/index.js';
 import { decodeFromBytecode } from './serialization/bytecode_serialization.js';
 
+type OpcodeTally = {
+  count: number;
+  gas: Gas;
+};
+type PcTally = {
+  opcode: string;
+  count: number;
+  gas: Gas;
+};
+
 export class AvmSimulator {
   private log: DebugLogger;
   private bytecode: Buffer | undefined;
+  public opcodeTallies: Map<string, OpcodeTally> = new Map();
+  public pcTallies: Map<number, PcTally> = new Map();
 
   constructor(private context: AvmContext) {
     assert(
@@ -33,10 +46,7 @@ export class AvmSimulator {
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
-    const bytecode = await this.context.persistableState.getBytecode(
-      this.context.environment.address,
-      this.context.environment.functionSelector,
-    );
+    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
 
     // This assumes that we will not be able to send messages to accounts without code
     // Pending classes and instances impl details
@@ -75,6 +85,7 @@ export class AvmSimulator {
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
+      let instrCounter = 0;
       while (!machineState.getHalted()) {
         const instruction = instructions[machineState.pc];
         assert(
@@ -82,13 +93,26 @@ export class AvmSimulator {
           'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
         );
 
-        const gasLeft = `l2=${machineState.l2GasLeft} da=${machineState.daGasLeft}`;
-        this.log.debug(`@${machineState.pc} ${instruction.toString()} (${gasLeft})`);
+        const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
+        const instrPc = machineState.pc; // Save PC before executing instruction (for profiling)
+
+        this.log.debug(
+          `[PC:${machineState.pc}] [IC:${instrCounter++}] ${instruction.toString()} (gasLeft l2=${
+            machineState.l2GasLeft
+          } da=${machineState.daGasLeft})`,
+        );
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
         await instruction.execute(this.context);
 
+        // gas used by this instruction - used for profiling/tallying
+        const gasUsed: Gas = {
+          l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
+          daGas: instrStartGas.daGas - machineState.daGasLeft,
+        };
+        this.tallyInstruction(instrPc, instruction.constructor.name, gasUsed);
+
         if (machineState.pc >= instructions.length) {
           this.log.warn('Passed end of program');
           throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
@@ -100,6 +124,8 @@ export class AvmSimulator {
       const revertReason = reverted ? revertReasonFromExplicitRevert(output, this.context) : undefined;
       const results = new AvmContractCallResult(reverted, output, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
+
+      this.printOpcodeTallies();
       // Return results for processing by calling context
       return results;
     } catch (err: any) {
@@ -113,8 +139,45 @@ export class AvmSimulator {
       // Note: "exceptional halts" cannot return data, hence []
       const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
+
+      this.printOpcodeTallies();
       // Return results for processing by calling context
       return results;
     }
   }
+
+  private tallyInstruction(pc: number, opcode: string, gasUsed: Gas) {
+    const opcodeTally = this.opcodeTallies.get(opcode) || ({ count: 0, gas: { l2Gas: 0, daGas: 0 } } as OpcodeTally);
+    opcodeTally.count++;
+    opcodeTally.gas.l2Gas += gasUsed.l2Gas;
+    opcodeTally.gas.daGas += gasUsed.daGas;
+    this.opcodeTallies.set(opcode, opcodeTally);
+
+    const pcTally = this.pcTallies.get(pc) || ({ opcode: opcode, count: 0, gas: { l2Gas: 0, daGas: 0 } } as PcTally);
+    pcTally.count++;
+    pcTally.gas.l2Gas += gasUsed.l2Gas;
+    pcTally.gas.daGas += gasUsed.daGas;
+    this.pcTallies.set(pc, pcTally);
+  }
+
+  private printOpcodeTallies() {
+    this.log.debug(`Printing tallies per opcode sorted by gas...`);
+    // sort descending by L2 gas consumed
+    const sortedOpcodes = Array.from(this.opcodeTallies.entries()).sort((a, b) => b[1].gas.l2Gas - a[1].gas.l2Gas);
+    for (const [opcode, tally] of sortedOpcodes) {
+      // NOTE: don't care to clutter the logs with DA gas for now
+      this.log.debug(`${opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`);
+    }
+
+    this.log.debug(`Printing tallies per PC sorted by #times each PC was executed...`);
+    const sortedPcs = Array.from(this.pcTallies.entries())
+      .sort((a, b) => b[1].count - a[1].count)
+      .filter((_, i) => i < 20);
+    for (const [pc, tally] of sortedPcs) {
+      // NOTE: don't care to clutter the logs with DA gas for now
+      this.log.debug(
+        `PC:${pc} containing opcode ${tally.opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`,
+      );
+    }
+  }
 }

package/src/avm/fixtures/index.ts

@@ -117,6 +117,13 @@ export function randomMemoryFields(length: number): Field[] {
   return [...Array(length)].map(_ => new Field(Fr.random()));
 }
 
+export function getAvmTestContractFunctionSelector(functionName: string): FunctionSelector {
+  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
+  const params = artifact.parameters;
+  return FunctionSelector.fromNameAndParameters(artifact.name, params);
+}
+
 export function getAvmTestContractBytecode(functionName: string): Buffer {
   const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
   assert(
@@ -147,10 +154,3 @@ export function resolveAvmTestContractAssertionMessage(
 
   return resolveAssertionMessage(revertReason.noirCallStack, debugMetadata);
 }
-
-export function getAvmTestContractFunctionSelector(functionName: string): FunctionSelector {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
-}

package/src/avm/journal/journal.ts

@@ -1,10 +1,16 @@
-import { AztecAddress, type FunctionSelector, type Gas, SerializableContractInstance } from '@aztec/circuits.js';
+import {
+  AztecAddress,
+  type Gas,
+  SerializableContractInstance,
+  computePublicBytecodeCommitment,
+} from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import assert from 'assert';
+
 import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { type WorldStateDB } from '../../public/public_db_sources.js';
-import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
@@ -210,22 +216,26 @@ export class AvmPersistableStateManager {
   /**
    * Get a contract instance.
    * @param contractAddress - address of the contract instance to retrieve.
-   * @returns the contract instance with an "exists" flag
+   * @returns the contract instance or undefined if it does not exist.
    */
-  public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
-    let exists = true;
-    const aztecAddress = AztecAddress.fromField(contractAddress);
-    let instance = await this.worldStateDB.getContractInstance(aztecAddress);
-    if (instance === undefined) {
-      instance = SerializableContractInstance.default().withAddress(aztecAddress);
-      exists = false;
+  public async getContractInstance(contractAddress: Fr): Promise<SerializableContractInstance | undefined> {
+    this.log.debug(`Getting contract instance for address ${contractAddress}`);
+    const instanceWithAddress = await this.worldStateDB.getContractInstance(AztecAddress.fromField(contractAddress));
+    const exists = instanceWithAddress !== undefined;
+
+    if (exists) {
+      const instance = new SerializableContractInstance(instanceWithAddress);
+      this.log.debug(
+        `Got contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
+      );
+      this.trace.traceGetContractInstance(contractAddress, exists, instance);
+
+      return Promise.resolve(instance);
+    } else {
+      this.log.debug(`Contract instance NOT FOUND (address=${contractAddress})`);
+      this.trace.traceGetContractInstance(contractAddress, exists);
+      return Promise.resolve(undefined);
     }
-    this.log.debug(
-      `Get Contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
-    );
-    const tracedInstance = { ...instance, exists };
-    this.trace.traceGetContractInstance(tracedInstance);
-    return Promise.resolve(tracedInstance);
   }
 
   /**
@@ -237,10 +247,43 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Get a contract's bytecode from the contracts DB
+   * Get a contract's bytecode from the contracts DB, also trace the contract class and instance
    */
-  public async getBytecode(contractAddress: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    return await this.worldStateDB.getBytecode(contractAddress, selector);
+  public async getBytecode(contractAddress: AztecAddress): Promise<Buffer | undefined> {
+    this.log.debug(`Getting bytecode for contract address ${contractAddress}`);
+    const instanceWithAddress = await this.worldStateDB.getContractInstance(contractAddress);
+    const exists = instanceWithAddress !== undefined;
+
+    if (exists) {
+      const instance = new SerializableContractInstance(instanceWithAddress);
+
+      const contractClass = await this.worldStateDB.getContractClass(instance.contractClassId);
+      assert(
+        contractClass,
+        `Contract class not found in DB, but a contract instance was found with this class ID (${instance.contractClassId}). This should not happen!`,
+      );
+
+      const contractClassPreimage = {
+        artifactHash: contractClass.artifactHash,
+        privateFunctionsRoot: contractClass.privateFunctionsRoot,
+        publicBytecodeCommitment: computePublicBytecodeCommitment(contractClass.packedBytecode),
+      };
+
+      this.trace.traceGetBytecode(
+        contractAddress,
+        exists,
+        contractClass.packedBytecode,
+        instance,
+        contractClassPreimage,
+      );
+      return contractClass.packedBytecode;
+    } else {
+      // If the contract instance is not found, we assume it has not been deployed.
+      // It doesnt matter what the values of the contract instance are in this case, as long as we tag it with exists=false.
+      // This will hint to the avm circuit to just perform the non-membership check on the address and disregard the bytecode hash
+      this.trace.traceGetBytecode(contractAddress, exists); // bytecode, instance, class undefined
+      return undefined;
+    }
   }
 
   /**

package/src/avm/opcodes/contract.ts

@@ -1,23 +1,36 @@
-import { Fr } from '@aztec/circuits.js';
-
 import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
+export enum ContractInstanceMember {
+  DEPLOYER,
+  CLASS_ID,
+  INIT_HASH,
+}
+
 export class GetContractInstance extends Instruction {
   static readonly type: string = 'GETCONTRACTINSTANCE';
   static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect bits
+    OperandType.UINT8, // member enum (immediate)
+    OperandType.UINT16, // addressOffset
+    OperandType.UINT16, // dstOffset
+    OperandType.UINT16, // existsOfsset
   ];
 
-  constructor(private indirect: number, private addressOffset: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private memberEnum: number,
+    private addressOffset: number,
+    private dstOffset: number,
+    private existsOffset: number,
+  ) {
     super();
   }
 
@@ -25,27 +38,38 @@ export class GetContractInstance extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost());
 
-    const operands = [this.addressOffset, this.dstOffset];
+    if (!(this.memberEnum in ContractInstanceMember)) {
+      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+    }
+
+    const operands = [this.addressOffset, this.dstOffset, this.existsOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
+    const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toFr();
     const instance = await context.persistableState.getContractInstance(address);
+    const exists = instance !== undefined;
 
-    const data = [
-      new Fr(instance.exists),
-      instance.salt,
-      instance.deployer.toField(),
-      instance.contractClassId,
-      instance.initializationHash,
-      // This this okay ?
-      ...instance.publicKeys.toFields(),
-    ].map(f => new Field(f));
+    let memberValue = new Field(0);
+    if (exists) {
+      switch (this.memberEnum as ContractInstanceMember) {
+        case ContractInstanceMember.DEPLOYER:
+          memberValue = new Field(instance.deployer.toField());
+          break;
+        case ContractInstanceMember.CLASS_ID:
+          memberValue = new Field(instance.contractClassId.toField());
+          break;
+        case ContractInstanceMember.INIT_HASH:
+          memberValue = new Field(instance.initializationHash);
+          break;
+      }
+    }
 
-    memory.setSlice(dstOffset, data);
+    memory.set(existsOffset, new Uint1(exists ? 1 : 0));
+    memory.set(dstOffset, memberValue);
 
-    memory.assert({ reads: 1, writes: 17, addressing });
+    memory.assert({ reads: 1, writes: 2, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -7,9 +7,9 @@ import { Instruction } from './instruction.js';
 
 export class Jump extends Instruction {
   static type: string = 'JUMP';
-  static readonly opcode: Opcode = Opcode.JUMP_16;
+  static readonly opcode: Opcode = Opcode.JUMP_32;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT16];
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
 
   constructor(private jumpOffset: number) {
     super();
@@ -26,13 +26,13 @@ export class Jump extends Instruction {
 
 export class JumpI extends Instruction {
   static type: string = 'JUMPI';
-  static readonly opcode: Opcode = Opcode.JUMPI_16;
+  static readonly opcode: Opcode = Opcode.JUMPI_32;
 
   // Instruction wire format with opcode.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT16,
+    OperandType.UINT32,
     OperandType.UINT16,
   ];
 
@@ -63,7 +63,7 @@ export class InternalCall extends Instruction {
   static readonly type: string = 'INTERNALCALL';
   static readonly opcode: Opcode = Opcode.INTERNALCALL;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT16];
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
 
   constructor(private loc: number) {
     super();

package/src/avm/opcodes/conversion.ts

@@ -5,9 +5,9 @@ import { Opcode, OperandType } from '../serialization/instruction_serialization.
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-export class ToRadixLE extends Instruction {
+export class ToRadixBE extends Instruction {
   static type: string = 'TORADIXLE';
-  static readonly opcode: Opcode = Opcode.TORADIXLE;
+  static readonly opcode: Opcode = Opcode.TORADIXBE;
 
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
@@ -44,15 +44,18 @@ export class ToRadixLE extends Instruction {
 
     let value: bigint = memory.get(srcOffset).toBigInt();
     const radix: bigint = memory.get(radixOffset).toBigInt();
+    if (this.numLimbs < 1) {
+      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${this.numLimbs})`);
+    }
     if (radix > 256) {
-      throw new InstructionExecutionError(`ToRadixLE instruction's radix should be <= 256 (was ${radix})`);
+      throw new InstructionExecutionError(`ToRadixBE instruction's radix should be <= 256 (was ${radix})`);
     }
     const radixBN: bigint = BigInt(radix);
-    const limbArray = [];
+    const limbArray = new Array(this.numLimbs);
 
-    for (let i = 0; i < this.numLimbs; i++) {
+    for (let i = this.numLimbs - 1; i >= 0; i--) {
       const limb = value % radixBN;
-      limbArray.push(limb);
+      limbArray[i] = limb;
       value /= radixBN;
     }
 

package/src/avm/opcodes/environment_getters.ts

@@ -1,5 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
 import { Field, Uint32, Uint64 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -63,7 +64,7 @@ export class GetEnvVar extends Instruction {
     OperandType.UINT16, // dstOffset
   ];
 
-  constructor(private indirect: number, private varEnum: EnvironmentVariable, private dstOffset: number) {
+  constructor(private indirect: number, private varEnum: number, private dstOffset: number) {
     super();
   }
 
@@ -71,11 +72,15 @@ export class GetEnvVar extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost());
 
+    if (!(this.varEnum in EnvironmentVariable)) {
+      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);
+    }
+
     const operands = [this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
-    memory.set(dstOffset, getValue(this.varEnum, context));
+    memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
 
     memory.assert({ writes: 1, addressing });
     context.machineState.incrementPc();