From b2fb0ec71867ca5a23c21e6f0114419be528b07d Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztecprotocol.com>
Date: Thu, 25 Jan 2024 15:42:06 -0300
Subject: [PATCH] feat: Contract classes and instances (#4192)

Adds `ContractInstance` and `ContractClass` interfaces as specified in
the yellow paper, with the addition of `PublicFunctions` in
`ContractClasses` until we remove them as first class citizens from the
protocol. Also includes hashes for contract classes and artifacts.
Stores contract classes and instances in the node in new tables, as well
as artifacts and instances in the pxe.

Fixes #4053
---
 yarn-project/archiver/package.json            |    3 +-
 .../archiver/src/archiver/archiver.ts         |   58 +-
 .../archiver/src/archiver/archiver_store.ts   |   29 +
 .../src/archiver/archiver_store_test_suite.ts |   42 +
 .../archiver/kv_archiver_store/block_store.ts |    2 -
 .../kv_archiver_store/contract_class_store.ts |   26 +
 .../contract_instance_store.ts                |   26 +
 .../kv_archiver_store/kv_archiver_store.ts    |   23 +
 .../memory_archiver_store.ts                  |   27 +
 yarn-project/archiver/tsconfig.json           |    3 +
 .../circuit-types/src/contract_data.ts        |    2 +-
 .../fixtures/Benchmarking.test.json           | 1699 +++++++++++++++++
 yarn-project/circuits.js/package.json         |    1 +
 .../src/abis/merkle_tree_calculator.ts        |   16 +-
 .../__snapshots__/contract_class.test.ts.snap |   48 +
 .../src/contract/artifact_hash.test.ts        |   11 +
 .../circuits.js/src/contract/artifact_hash.ts |   67 +
 .../src/contract/contract_class.test.ts       |   15 +
 .../src/contract/contract_class.ts            |   45 +
 .../src/contract/contract_class_id.test.ts    |   34 +
 .../src/contract/contract_class_id.ts         |   78 +
 .../circuits.js/src/contract/index.ts         |    3 +
 .../circuits.js/src/tests/fixtures.ts         |   13 +
 yarn-project/circuits.js/tsconfig.json        |    3 +
 yarn-project/foundation/src/abi/selector.ts   |   11 +-
 .../foundation/src/eth-address/index.ts       |    2 +-
 .../foundation/src/serialize/buffer_reader.ts |   11 +
 yarn-project/pxe/package.json                 |    1 +
 .../contracts/contract_artifact_db.ts         |   19 +
 .../contracts/contract_instance_db.ts         |   18 +
 .../pxe/src/database/kv_pxe_database.ts       |   29 +
 yarn-project/pxe/src/database/memory_db.ts    |   25 +
 yarn-project/pxe/src/database/pxe_database.ts |    4 +-
 .../src/database/pxe_database_test_suite.ts   |   18 +
 .../pxe/src/pxe_service/pxe_service.ts        |   27 +
 yarn-project/pxe/tsconfig.json                |    3 +
 yarn-project/types/package.json               |    1 +
 .../types/src/abi/contract_artifact.ts        |   20 +
 .../src/contracts/contract_class.test.ts      |    8 +
 .../types/src/contracts/contract_class.ts     |  175 ++
 .../src/contracts/contract_instance.test.ts   |    8 +
 .../types/src/contracts/contract_instance.ts  |   83 +
 yarn-project/types/src/contracts/index.ts     |    2 +
 yarn-project/yarn.lock                        |    3 +
 44 files changed, 2729 insertions(+), 13 deletions(-)
 create mode 100644 yarn-project/archiver/src/archiver/kv_archiver_store/contract_class_store.ts
 create mode 100644 yarn-project/archiver/src/archiver/kv_archiver_store/contract_instance_store.ts
 create mode 100644 yarn-project/circuits.js/fixtures/Benchmarking.test.json
 create mode 100644 yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap
 create mode 100644 yarn-project/circuits.js/src/contract/artifact_hash.test.ts
 create mode 100644 yarn-project/circuits.js/src/contract/artifact_hash.ts
 create mode 100644 yarn-project/circuits.js/src/contract/contract_class.test.ts
 create mode 100644 yarn-project/circuits.js/src/contract/contract_class.ts
 create mode 100644 yarn-project/circuits.js/src/contract/contract_class_id.test.ts
 create mode 100644 yarn-project/circuits.js/src/contract/contract_class_id.ts
 create mode 100644 yarn-project/circuits.js/src/tests/fixtures.ts
 create mode 100644 yarn-project/pxe/src/database/contracts/contract_artifact_db.ts
 create mode 100644 yarn-project/pxe/src/database/contracts/contract_instance_db.ts
 create mode 100644 yarn-project/types/src/contracts/contract_class.test.ts
 create mode 100644 yarn-project/types/src/contracts/contract_class.ts
 create mode 100644 yarn-project/types/src/contracts/contract_instance.test.ts
 create mode 100644 yarn-project/types/src/contracts/contract_instance.ts
 create mode 100644 yarn-project/types/src/contracts/index.ts

diff --git a/yarn-project/archiver/package.json b/yarn-project/archiver/package.json
index b837e1d9b38..6a6048af0d3 100644
--- a/yarn-project/archiver/package.json
+++ b/yarn-project/archiver/package.json
@@ -41,7 +41,7 @@
     "@aztec/foundation": "workspace:^",
     "@aztec/kv-store": "workspace:^",
     "@aztec/l1-artifacts": "workspace:^",
-    "@types/lodash.omit": "^4.5.7",
+    "@aztec/types": "workspace:^",
     "debug": "^4.3.4",
     "lmdb": "^2.9.1",
     "lodash.omit": "^4.5.0",
@@ -54,6 +54,7 @@
     "@jest/globals": "^29.5.0",
     "@types/debug": "^4.1.7",
     "@types/jest": "^29.5.0",
+    "@types/lodash.omit": "^4.5.7",
     "@types/node": "^18.15.11",
     "@types/ws": "^8.5.4",
     "concurrently": "^8.0.1",
diff --git a/yarn-project/archiver/src/archiver/archiver.ts b/yarn-project/archiver/src/archiver/archiver.ts
index 26eaaa71eeb..780020a012c 100644
--- a/yarn-project/archiver/src/archiver/archiver.ts
+++ b/yarn-project/archiver/src/archiver/archiver.ts
@@ -15,7 +15,7 @@ import {
   LogType,
   TxHash,
 } from '@aztec/circuit-types';
-import { FunctionSelector, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
+import { FunctionSelector, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, getContractClassId } from '@aztec/circuits.js';
 import { createEthereumChain } from '@aztec/ethereum';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -23,6 +23,12 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import {
+  ContractClass,
+  ContractClassWithId,
+  ContractInstance,
+  ContractInstanceWithAddress,
+} from '@aztec/types/contracts';
 
 import omit from 'lodash.omit';
 import { Chain, HttpTransport, PublicClient, createPublicClient, http } from 'viem';
@@ -268,6 +274,7 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
         this.log(`Retrieved extended contract data for l2 block number: ${l2BlockNum}`);
         if (l2BlockNum <= lastKnownL2BlockNum) {
           await this.store.addExtendedContractData(contracts, l2BlockNum);
+          await this.storeContractDataAsClassesAndInstances(contracts, l2BlockNum);
         }
       }),
     );
@@ -294,6 +301,24 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
     );
   }
 
+  /**
+   * Stores extended contract data as classes and instances.
+   * Temporary solution until we source this data from the contract class registerer and instance deployer.
+   * @param contracts - The extended contract data to be stored.
+   * @param l2BlockNum - The L2 block number to which the contract data corresponds.
+   */
+  async storeContractDataAsClassesAndInstances(contracts: ExtendedContractData[], l2BlockNum: number) {
+    const classesAndInstances = contracts.map(extendedContractDataToContractClassAndInstance);
+    await this.store.addContractClasses(
+      classesAndInstances.map(([c, _]) => c),
+      l2BlockNum,
+    );
+    await this.store.addContractInstances(
+      classesAndInstances.map(([_, i]) => i),
+      l2BlockNum,
+    );
+  }
+
   /**
    * Stops the archiver.
    * @returns A promise signalling completion of the stop process.
@@ -440,3 +465,34 @@ export class Archiver implements L2BlockSource, L2LogsSource, ContractDataSource
     return this.store.getConfirmedL1ToL2Message(messageKey);
   }
 }
+
+/** Converts ExtendedContractData into contract classes and instances. */
+function extendedContractDataToContractClassAndInstance(
+  data: ExtendedContractData,
+): [ContractClassWithId, ContractInstanceWithAddress] {
+  const contractClass: ContractClass = {
+    version: 1,
+    artifactHash: Fr.ZERO,
+    publicFunctions: data.publicFunctions.map(f => ({
+      selector: f.selector,
+      bytecode: f.bytecode,
+      isInternal: f.isInternal,
+    })),
+    privateFunctions: [],
+    packedBytecode: data.bytecode,
+  };
+  const contractClassId = getContractClassId(contractClass);
+  const contractInstance: ContractInstance = {
+    version: 1,
+    salt: Fr.ZERO,
+    contractClassId,
+    initializationHash: Fr.ZERO,
+    portalContractAddress: data.contractData.portalContractAddress,
+    publicKeysHash: data.partialAddress,
+  };
+  const address = data.contractData.contractAddress;
+  return [
+    { ...contractClass, id: contractClassId },
+    { ...contractInstance, address },
+  ];
+}
diff --git a/yarn-project/archiver/src/archiver/archiver_store.ts b/yarn-project/archiver/src/archiver/archiver_store.ts
index 0d4c1f13c26..c8d033d40fd 100644
--- a/yarn-project/archiver/src/archiver/archiver_store.ts
+++ b/yarn-project/archiver/src/archiver/archiver_store.ts
@@ -12,6 +12,7 @@ import {
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 /**
  * Represents the latest L1 block processed by the archiver for various objects in L2.
@@ -167,4 +168,32 @@ export interface ArchiverDataStore {
    * Gets the last L1 block number processed by the archiver
    */
   getL1BlockNumber(): Promise<ArchiverL1SynchPoint>;
+
+  /**
+   * Add new contract classes from an L2 block to the store's list.
+   * @param data - List of contract classes to be added.
+   * @param blockNumber - Number of the L2 block the contracts were registered in.
+   * @returns True if the operation is successful.
+   */
+  addContractClasses(data: ContractClassWithId[], blockNumber: number): Promise<boolean>;
+
+  /**
+   * Returns a contract class given its id, or undefined if not exists.
+   * @param id - Id of the contract class.
+   */
+  getContractClass(id: Fr): Promise<ContractClassWithId | undefined>;
+
+  /**
+   * Add new contract instances from an L2 block to the store's list.
+   * @param data - List of contract instances to be added.
+   * @param blockNumber - Number of the L2 block the instances were deployed in.
+   * @returns True if the operation is successful.
+   */
+  addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean>;
+
+  /**
+   * Returns a contract instance given its address, or undefined if not exists.
+   * @param address - Address of the contract.
+   */
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
 }
diff --git a/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts b/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts
index 788c0894d4e..592addaefb0 100644
--- a/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts
+++ b/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts
@@ -12,6 +12,12 @@ import {
 import '@aztec/circuit-types/jest';
 import { AztecAddress, Fr } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
+import {
+  ContractClassWithId,
+  ContractInstanceWithAddress,
+  SerializableContractClass,
+  SerializableContractInstance,
+} from '@aztec/types/contracts';
 
 import { ArchiverDataStore } from './archiver_store.js';
 
@@ -320,6 +326,42 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
     });
 
+    describe('contractInstances', () => {
+      let contractInstance: ContractInstanceWithAddress;
+      const blockNum = 10;
+
+      beforeEach(async () => {
+        contractInstance = { ...SerializableContractInstance.random(), address: AztecAddress.random() };
+        await store.addContractInstances([contractInstance], blockNum);
+      });
+
+      it('returns previously stored contract instances', async () => {
+        await expect(store.getContractInstance(contractInstance.address)).resolves.toMatchObject(contractInstance);
+      });
+
+      it('returns undefined if contract instance is not found', async () => {
+        await expect(store.getContractInstance(AztecAddress.random())).resolves.toBeUndefined();
+      });
+    });
+
+    describe('contractClasses', () => {
+      let contractClass: ContractClassWithId;
+      const blockNum = 10;
+
+      beforeEach(async () => {
+        contractClass = { ...SerializableContractClass.random(), id: Fr.random() };
+        await store.addContractClasses([contractClass], blockNum);
+      });
+
+      it('returns previously stored contract class', async () => {
+        await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
+      });
+
+      it('returns undefined if contract class is not found', async () => {
+        await expect(store.getContractClass(Fr.random())).resolves.toBeUndefined();
+      });
+    });
+
     describe('getContractData', () => {
       let block: L2Block;
       beforeEach(async () => {
diff --git a/yarn-project/archiver/src/archiver/kv_archiver_store/block_store.ts b/yarn-project/archiver/src/archiver/kv_archiver_store/block_store.ts
index 025221fe73f..3a2446fa0d5 100644
--- a/yarn-project/archiver/src/archiver/kv_archiver_store/block_store.ts
+++ b/yarn-project/archiver/src/archiver/kv_archiver_store/block_store.ts
@@ -3,7 +3,6 @@ import { AztecAddress } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore, AztecMap, Range } from '@aztec/kv-store';
 
-/* eslint-disable */
 type BlockIndexValue = [blockNumber: number, index: number];
 
 type BlockContext = {
@@ -12,7 +11,6 @@ type BlockContext = {
   block: Buffer;
   blockHash: Buffer;
 };
-/* eslint-enable */
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
diff --git a/yarn-project/archiver/src/archiver/kv_archiver_store/contract_class_store.ts b/yarn-project/archiver/src/archiver/kv_archiver_store/contract_class_store.ts
new file mode 100644
index 00000000000..6cd56d90e4d
--- /dev/null
+++ b/yarn-project/archiver/src/archiver/kv_archiver_store/contract_class_store.ts
@@ -0,0 +1,26 @@
+import { Fr } from '@aztec/foundation/fields';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import { ContractClassWithId, SerializableContractClass } from '@aztec/types/contracts';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class ContractClassStore {
+  #contractClasses: AztecMap<string, Buffer>;
+
+  constructor(db: AztecKVStore) {
+    this.#contractClasses = db.createMap('archiver_contract_classes');
+  }
+
+  addContractClass(contractClass: ContractClassWithId): Promise<boolean> {
+    return this.#contractClasses.set(
+      contractClass.id.toString(),
+      new SerializableContractClass(contractClass).toBuffer(),
+    );
+  }
+
+  getContractClass(id: Fr): ContractClassWithId | undefined {
+    const contractClass = this.#contractClasses.get(id.toString());
+    return contractClass && SerializableContractClass.fromBuffer(contractClass).withId(id);
+  }
+}
diff --git a/yarn-project/archiver/src/archiver/kv_archiver_store/contract_instance_store.ts b/yarn-project/archiver/src/archiver/kv_archiver_store/contract_instance_store.ts
new file mode 100644
index 00000000000..7842b54f2f4
--- /dev/null
+++ b/yarn-project/archiver/src/archiver/kv_archiver_store/contract_instance_store.ts
@@ -0,0 +1,26 @@
+import { AztecAddress } from '@aztec/circuits.js';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import { ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class ContractInstanceStore {
+  #contractInstances: AztecMap<string, Buffer>;
+
+  constructor(db: AztecKVStore) {
+    this.#contractInstances = db.createMap('archiver_contract_instances');
+  }
+
+  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<boolean> {
+    return this.#contractInstances.set(
+      contractInstance.address.toString(),
+      new SerializableContractInstance(contractInstance).toBuffer(),
+    );
+  }
+
+  getContractInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
+    const contractInstance = this.#contractInstances.get(address.toString());
+    return contractInstance && SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
+  }
+}
diff --git a/yarn-project/archiver/src/archiver/kv_archiver_store/kv_archiver_store.ts b/yarn-project/archiver/src/archiver/kv_archiver_store/kv_archiver_store.ts
index 74be29d9d58..db9f0e4cddd 100644
--- a/yarn-project/archiver/src/archiver/kv_archiver_store/kv_archiver_store.ts
+++ b/yarn-project/archiver/src/archiver/kv_archiver_store/kv_archiver_store.ts
@@ -14,9 +14,12 @@ import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore } from '@aztec/kv-store';
+import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import { BlockStore } from './block_store.js';
+import { ContractClassStore } from './contract_class_store.js';
+import { ContractInstanceStore } from './contract_instance_store.js';
 import { ContractStore } from './contract_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
@@ -29,6 +32,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   #logStore: LogStore;
   #contractStore: ContractStore;
   #messageStore: MessageStore;
+  #contractClassStore: ContractClassStore;
+  #contractInstanceStore: ContractInstanceStore;
 
   #log = createDebugLogger('aztec:archiver:lmdb');
 
@@ -37,6 +42,24 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#contractStore = new ContractStore(db, this.#blockStore);
     this.#messageStore = new MessageStore(db);
+    this.#contractClassStore = new ContractClassStore(db);
+    this.#contractInstanceStore = new ContractInstanceStore(db);
+  }
+
+  getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
+    return Promise.resolve(this.#contractClassStore.getContractClass(id));
+  }
+
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(this.#contractInstanceStore.getContractInstance(address));
+  }
+
+  async addContractClasses(data: ContractClassWithId[], _blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractClassStore.addContractClass(c)))).every(Boolean);
+  }
+
+  async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
   }
 
   /**
diff --git a/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts b/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts
index 62824ae1fe3..ecd0afda6d8 100644
--- a/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts
+++ b/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts
@@ -17,6 +17,7 @@ import {
 } from '@aztec/circuit-types';
 import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { ArchiverDataStore } from '../archiver_store.js';
 import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
@@ -68,6 +69,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   private pendingL1ToL2Messages: PendingL1ToL2MessageStore = new PendingL1ToL2MessageStore();
 
+  private contractClasses: Map<string, ContractClassWithId> = new Map();
+
+  private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
+
   private lastL1BlockAddedMessages: bigint = 0n;
   private lastL1BlockCancelledMessages: bigint = 0n;
 
@@ -76,6 +81,28 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     public readonly maxLogs: number,
   ) {}
 
+  public getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
+    return Promise.resolve(this.contractClasses.get(id.toString()));
+  }
+
+  public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(this.contractInstances.get(address.toString()));
+  }
+
+  public addContractClasses(data: ContractClassWithId[], _blockNumber: number): Promise<boolean> {
+    for (const contractClass of data) {
+      this.contractClasses.set(contractClass.id.toString(), contractClass);
+    }
+    return Promise.resolve(true);
+  }
+
+  public addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    for (const contractInstance of data) {
+      this.contractInstances.set(contractInstance.address.toString(), contractInstance);
+    }
+    return Promise.resolve(true);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store.
diff --git a/yarn-project/archiver/tsconfig.json b/yarn-project/archiver/tsconfig.json
index 6a0c794ba6d..69fe51229cc 100644
--- a/yarn-project/archiver/tsconfig.json
+++ b/yarn-project/archiver/tsconfig.json
@@ -23,6 +23,9 @@
     },
     {
       "path": "../l1-artifacts"
+    },
+    {
+      "path": "../types"
     }
   ],
   "include": ["src"]
diff --git a/yarn-project/circuit-types/src/contract_data.ts b/yarn-project/circuit-types/src/contract_data.ts
index 1da2b034bc3..a84e0434d23 100644
--- a/yarn-project/circuit-types/src/contract_data.ts
+++ b/yarn-project/circuit-types/src/contract_data.ts
@@ -125,7 +125,7 @@ export class ExtendedContractData {
     /** The base contract data: aztec & portal addresses. */
     public contractData: ContractData,
     /** Artifacts of public functions. */
-    private publicFunctions: EncodedContractFunction[],
+    public readonly publicFunctions: EncodedContractFunction[],
     /** Partial addresses of the contract. */
     public readonly partialAddress: PartialAddress,
     /** Public key of the contract. */
diff --git a/yarn-project/circuits.js/fixtures/Benchmarking.test.json b/yarn-project/circuits.js/fixtures/Benchmarking.test.json
new file mode 100644
index 00000000000..9ee5d2c91c3
--- /dev/null
+++ b/yarn-project/circuits.js/fixtures/Benchmarking.test.json
@@ -0,0 +1,1699 @@
+{
+  "noir_version": "0.23.0+602f23f4fb698cf6e37071936a2a46593a998d08",
+  "name": "Benchmarking",
+  "functions": [
+    {
+      "name": "increment_balance",
+      "function_type": "Open",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::abi::PublicContextInputs",
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::call_context::CallContext",
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "storage_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "function_selector",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                          "fields": [
+                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                          ]
+                        }
+                      },
+                      { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                      { "name": "is_static_call", "type": { "kind": "boolean" } },
+                      { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                      {
+                        "name": "start_side_effect_counter",
+                        "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "block_header",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                    "fields": [
+                      { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                      { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_tree_root", "type": { "kind": "field" } },
+                      { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                      { "name": "archive_root", "type": { "kind": "field" } },
+                      { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                      { "name": "global_variables_hash", "type": { "kind": "field" } }
+                    ]
+                  }
+                },
+                {
+                  "name": "public_global_variables",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::abi::PublicGlobalVariables",
+                    "fields": [
+                      { "name": "chain_id", "type": { "kind": "field" } },
+                      { "name": "version", "type": { "kind": "field" } },
+                      { "name": "block_number", "type": { "kind": "field" } },
+                      { "name": "timestamp", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "owner",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::AztecAddress",
+              "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+            },
+            "visibility": "private"
+          },
+          { "name": "value", "type": { "kind": "field" }, "visibility": "private" }
+        ],
+        "param_witnesses": {
+          "inputs": [{ "start": 0, "end": 19 }],
+          "owner": [{ "start": 19, "end": 20 }],
+          "value": [{ "start": 20, "end": 21 }]
+        },
+        "return_type": {
+          "abi_type": {
+            "kind": "struct",
+            "path": "aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs",
+            "fields": [
+              {
+                "name": "call_context",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::call_context::CallContext",
+                  "fields": [
+                    {
+                      "name": "msg_sender",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "storage_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "function_selector",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                        "fields": [{ "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }]
+                      }
+                    },
+                    { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                    { "name": "is_static_call", "type": { "kind": "boolean" } },
+                    { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                    {
+                      "name": "start_side_effect_counter",
+                      "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                    }
+                  ]
+                }
+              },
+              { "name": "args_hash", "type": { "kind": "field" } },
+              { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+              {
+                "name": "contract_storage_update_requests",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest",
+                    "fields": [
+                      { "name": "storage_slot", "type": { "kind": "field" } },
+                      { "name": "old_value", "type": { "kind": "field" } },
+                      { "name": "new_value", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "contract_storage_reads",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::storage_read::StorageRead",
+                    "fields": [
+                      { "name": "storage_slot", "type": { "kind": "field" } },
+                      { "name": "current_value", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "public_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              {
+                "name": "new_commitments",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_nullifiers",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "note_hash", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              {
+                "name": "unencrypted_logs_hash",
+                "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
+              },
+              { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
+              {
+                "name": "block_header",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                  "fields": [
+                    { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                    { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_tree_root", "type": { "kind": "field" } },
+                    { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                    { "name": "archive_root", "type": { "kind": "field" } },
+                    { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                    { "name": "global_variables_hash", "type": { "kind": "field" } }
+                  ]
+                }
+              },
+              {
+                "name": "prover_address",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::address::AztecAddress",
+                  "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                }
+              }
+            ]
+          },
+          "visibility": "public"
+        },
+        "return_witnesses": [
+          21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+          75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
+          102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
+          124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
+          146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
+          168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
+          190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210
+        ]
+      },
+      "bytecode": "H4sIAAAAAAAA/+2dCXwdVfXH38tL0ry87PvSJC9N0zYNafPSjVrUuFGKCxREqqKlW7DYptgmLAqKirivdUUUBRXcV9wXRFEQZFNQVNxAQfa1LGX5nzvvHvLLzfQl8+felxN65/M5yZ1zZ+75nnPv3Llv5s7MtbFYLB7LLgmS+tjEhfMH9f/+p7dkLJbV75IzPkM4C2YIZ2KGcBbOEM6iGcJZPEM4Z80QzpIZwpmcIZylM4QzNUM4y2YIZ/kM4ayYIZyVM4SzaoZwVs8QzpoZwlk7QzjrLHK2ACf/tmvQ/xv1/yb9v1n/531a9f/Z+n+b9rVQr7eTdJCkSTp1HgdmDkkXyVySbpJ5JPNJFpD0kCwk6SU5gKSPZBHJYr2/+oE4QLKEZCnJMpLlJCtIDiRZSfIsklUkB5E8m+Q5JM/VcXseyfNJXkDyQpIXkRxMsprkEJI1JIeSvJjkJSQvJXkZyWEkh5Os1b6ktS9HkBxJ8nKSo0heQXI0yTqSV5K8iuTVJMeQvIbktSTrSY4l2UCykWQTyWaSLSRDJMeRvI5kK8nxJK8n2UaynWSYZAfJCSRvMGK+k2QXyQjJqMF5IslJJCeTnELyRpI3kZxKchrJm0neQnI6yVtJ3kbydpIzSN5BcibJO0neRfJukveQvJfkfSTvJ/kAyQdJPkTyYZKPkOwm+SjJx2Lj6//jJJ8g+STJp0jOIvk0ydkknyH5LMk5JJ8j+TzJuSTnkXyB5IskXyI5n+QCki+TfIXkqyRfI/k6yTdIvknyLZJvk3yH5Lsk3yO5kOT7JD8g+SHJj0h+TPITkp+S/Izk5yS/ILmI5JckF5P8iuTXJJdoXwq0L78h+a2hu5TkMp3+nf5/uf5/hf7/e/3/Sv3/Kv3/av3/Gv3/WsVfnU2rMbN5DUbp+JiNg46P3wLQ8bGcAB0f14Wg42O8CHR8vBeDjo/9WaBr0+kS0LVDmv936HQp6NI6nQJdp06XgW6OTpeDrkunK0A3V6crQdet01Wgm6fT1aCbr9M1oFug07Wg69HpOv2f46OWQf2//2kuqkzL55F+xc5tox784bbRADpuG42g47bRBDr2vRl03DZaQMdtoxV03DZmg47bRhvouG1gm+K20QE6bhtp0HHb6AQdt405oOO20QU6bhtzQcdtoxt03DbmgY7bxnzQccwXgI5jzm1KxfgQyOcFj2m8Pss6zsdjOgFlso7z8ZjmfDymOR+Paczn/5yPxzTn4zHN+Xj8cj4eq1yveFzyPngMcr1iO+ZysM1yvWL75LKxLXK9Yltke9gWuV6xLTIDtkWu1zTomAvbIh9L2BaZFfu3YihrUP/vf3pLBvtkXuLG+iCk0/p/MfhgiaU/BSydYKfLrp0leC6Zis9dwNJt2Wc8X02FpRtY5tllCa7JzrdbZlCnHGvsQ9nOHPBngWV/4mCHy+V1tpUCHfbnC0L4euzyDcTBDpfL6z3Ax7p57mLVj30Tl63OExvAZtqyTeU/H+d834IZ2FYCtjmyeoxri9aVQj6OLXl/7FO7DZ2LYygOdrhcXp8HfNyndOeXb2CqfHMNPgd9XxCruQZLmF3Lx11oHXEb6nFs1+yPugy7+LuEl1zng/nAa7v/VGUutFtmcMz3AvMg2MDz7AEOYt8L8YyDDdYnIH1GbGw5ANJp/Z+Z1bHSE7IdpucZ+6Qgv8exzwuBYxDW2ZbqS08BBsttPqjvHoOB17tAvzAkXngO5PwG0HF/3w26OUYZ+Fsd+1XL7TqTy0+sd9bhb8KFIXy9dvkGcrWFXuBj3QLHsdrXuGfhfmzX9rGH5avjnI8TtpOA/I6Cse3OBibLv70Gov7ewXNC2ipLpj/q78A0sFj+7Rucazvsltnvuk3FIH7Mjn0InttcHFMdRj3xOvJ5Vs/qWT2rZ/WsntWzetb9m1WxzDU48R7YXAF8YffAbP82wPuOXLb67Xcn2Jxj1WYmuBZk/p4z730mYJsngetenS6FfLyf1Gno7P9ezNYf2+FyeT0NfOwL1p/t34vx2PjfroPPaLsDm+wfA5l+Nc8A5xCZx11a/8e5UaxTbXJOwZi/do+V7H15vD6qllzXJuY4i332Hm6XERv79THQj/MWC2Lj+4cOsGvpmkaGE3htlOPHHGHXykp1RZTb5XmKayr3hV3dm8Fr2OnY2DVDtoXXq3lb855OOjbxPgneW6nR8VPH0IXxsf0st9uBqNf3sG3brdOBfpznOBUWrGfL534n9/Uc3LMIrjXmuveG99Gw/U3HfTTP6lk9q2f1rJ7Vs3pWz+pZPatn9aye1bN6Vs/qWT2rZ51JrDifPq3/72u++nTxsQ7vD9m+to3P43LZ6t7FeXDvIm3V5sC4Z+O4/GajLvDZuBvhnsr5Ol0K+WFzHbD+XNzD2tdcB7ZVCr5g/dm+34H3FbncZ67d7L1yu8fAwFP3yrk9mccdPqtjPtOG9/lwfgTO30gbuumqDzxm0qDjNM5fsRvjjIt7aMF7dQ+AemDf8Jk3zr8I+pCL42N1Y/YXKv+akHxe4sb6IKTxPvsiu74GfeZiKH8QbKDdfrt2M2g3Hhv/ziPWJyB9NQQIXxrG8WVm1e76QrbDdIexTwry+xz7vAg4BmGdbal2cgm0qWvgfGn7fIP+YlyaIC6cn4a42D7elIvm+I4Z8Dm7uQYnjquwD+xzwLevcVUf8JlzPHC+IPYnOF8wbZV1/BjInA+UBruWzhPj5gPh/IvO2MR3DCRgm5t0u1bzgcxxTxr2bYYy8zGHyTw34xymW4HZz2EKn8Nkzs3FOUz3QL/WWpBN72u8LeX5YxzHoN89+/Ab38Hgop9kriKDA8cmvM2j0F7Vgn3sPP0fx3Dmb0X7442BYLy22GqZ2fMYnj/TOo3jCM6PF4xtl9DpJPjcCeXUhOTzkmu8tgjiN2DX1+BYXQLlD4INtLvUrt0M2uXxGttgfQLS1QVj8Vg6lnwqvsys2l0mZDtMH2Dsk4L8jGOfB4BjENbZlmonxdCmuM24GIegvxiXZogL5+O1sTnG9qo94/tlmdf2cYljei7XHOOHjb3x/GB/jDTxmYR0bOJ1Irx+hX0CXr9y8XwJz5nH50vmOIzF//dddvjMDR/qrub0d0bgmwN8vF8C+OY64IvyzMFc4OP98N2S8xzwdUfgmwd8vF8R8Nl+XxK+124qfGHvoCuG/7bHiDgWnQof9ru83yzgs33NX/H1RuDD+wC8XwnwWb6+FPD1ReDDazK8XxL4bF+TUWUvjsDXD3y8XynwWR7vBXyZCHw4RspAmvlsj5EU35IIfEuBifcrA77lDviWReBbDny8XznwHeiAb0UEvgOBj/erAL5nOeBbGYHvWcDH+1UC30EO+FZF4DsI+Hi/KuB7jgO+Z0fgew7w8X7VwDfogO+5EfgGgY/3qwG+5zvge14EvucDH+9XC3wvdMD3ggh8LwQ+3g/fh3+wA74XReA7GPh4Pzz/HuKAb3UEvkOAj/drAb5D7fIFz0OuicB3KLC81C7LUsXy4ggsLwWWl9hlCZ6HfJndMoNrg4dZLlOVcTjEhOPH7CnIPwzidbjleMXBJpfL68jnWfdvVsWyxuBMwnZrBPCx7iUOWZIGi1py9XVhfFiXR9jlC84LayPwHQEsR1llWRJcNzwyAstRwPJyqyzZ88Ir7JYZ9OFHAz/7ynZSkI91frRl3+Jgk8vldeTzrJ7Vs3pWz+pZPatn9aye1bN6Vs/qWT2rZ/WsntWzelbP6lk9q2f1rJ7Vs3pWz+pZPat9VsWy1uBMwnZrBfCx7uUOWZIGi1pyzRMJ48O6fKVdvmBOzboIfK8ElmOssmS/PfGqCCzHAMurrbJk59S8xm6ZwZya1wI/+8p2UpCPdf5ay77FwSaXy+vI51k9q2f1rJ7Vs3pWz+pZPatn9aye1bN6Vs/qWT2rZ/WsM4VVsawzOJOw3ToBfKx7tUOWpMGillzX2cP4sC6PtcsX3JNYH4HvWGDZZJcleP/Dhggsm4Blo12W4J7EZrtlBvcktgA/+8p2UpCPdb7Fsm9xsMnl8jryedb9m1WxrDc4k7DdegF8rNvokCVpsKglV78Uxod1eZxdvqAPH4rAdxywHG+VJXtf+XURWI4Hlq1WWbJ9+Ovtlhn04duAn31lOynIxzrfZtm3ONjkcnl9mzu7gf/bJ/F/ewjH9jz6j3xTZT1sBrH6uPq4+rj6uPq4+rj6uPq4+rj6uPq4+rj6uPq4+rj6uPq4+rj6uE6dVbEMGZxJ2G5IAB/rtjpkSRosasl17T6MD9vdDrt8wX2O4Qh8O4Blp1WW7DupT4jAshNY3mCVJXufY5fdMoPr/CPAz76ynRTkY52PWPYtDja5XF5Hvmci67YZxOrbgBtW3wY8q28DntW3Ac/q24Bn9W3As/o24Fl9G/Csvg14Vt8GPKtvA57VtwHP6tuAZ/VtwLP6NuBZp7sNKJZhgzMJ2w0L4GPdGxyyJA0WteSaJxLGh+3uRLt8wZya0Qh8JwLLKQ5YTorAcgqwnGyXJZhT80a7ZfarMt4E/Owr20lBPtb5myz7FgebXC6vI99MYVUsowZnErYbFcDHupMdsiQNFrXkOn7C+LAuT7PLFxzfp0bgOw1YTnfA8uYILKcDy1vssgR9zVvtlhn0NW8DfvaV7aQgH+v8bZZ9i4NNLpfXkW+msCqWUw3OJGx3qgA+1r3FIUvSYFFLruMnjA/r8gwHfG+PwHcG8L09hO9MB3zviMB3JvDxfqXA9y4HfO+MwPcu4HsnpJnvPQ743h2B7z3AxPuVAd/7HPC9NwLf+4CP9ysHvg844Ht/BL4PAB/vVwF8H3LA98EIfB8CPt6vEvg+4oDvwxH4PgJ8vF8V8H3UAd/uCHwfBT7eD/u/jzvg+1gEvo8D38dC+D7pgO8TEfg+CXyfCOE7ywHfpyLwnQV8nwrhO9sB36cj8J0NfLwfXsP6rAO+z0Tg+yywnGOXpT8FLOeAnc878Plzsan7zPZTsB/yneeA79wIfOcB37khfF90wPeFCHxfBD7eD9v0+Q74vhSB73zg4/2wT/iyA74LIvB9GfguCOH7qgO+r0Tg+yrwfSWE7+sO+L4Wge/rwPe1EL5vOuD7RgS+bwLfN0L4vu2A71sR+L4NfN8K4fuuA77vROD7LvB9J4TvQgd834vAdyHwfS+E7wcO+L4fge8HwPf9EL4fOeD7YQS+HwHfD0P4fuKA78cR+H4CfD8O4fuZA76fRuD7GfD9NITvFw74fh6B7xfA9/MQvl864LsoAt8vge+iEL5fOeC7OALfr4Dv4hC+Sxzw/ToC3yXAx/vh+O+3Dvh+E4Hvt8DH+2H8LrPLF9xzuTQC32XAcoVdluBbA7+LwHIFsFxulyW4//N7u2UG93+uBH72le2kIB/r/ErLvsXBJpfL68jnWfdvVsVyqcGZhO0uFcDHussdsiQNFrXk6pfC+LAur7bLF/ThV0XguxpY/mCVZWnwDp5rIrD8AViutcqS7cP/aLfMoA+/DvjZV7aTgnys8+ss+xYHm1wuryPfVFm3zSBWH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cf16mzKparDM4kbHeVAD7WXeuQJWmwqCXXPOcwPmx3f7LLF8wJvz4C35+A5S9WWQaCOeF/jsDyF2C5wSpLdk74X+2WGcwJ/xvws69sJwX5WOd/s+xbHGxyubyOfFNl3TaDWH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cfVx9XH1cn5lxVSzXG5xJ2O56AXysu8EhS9JgUUuu6+xhfNju/m6XL7gncWMEvr8Dy7+ssiwJ7kn8IwLLv4Dln1ZZsvck/m23zOCexE3Az76ynRTkY53fZNm3ONjkcnkd+Z6JrNtmEKtvA25YfRvwrL4NeFbfBjyrbwOe1bcBz+rbgGf1bcCz+jbgWX0b8Ky+DXhW3wY8q28DntW3Ac/q24Bnne42oFhuNDiTsN2NAvhY90+HLEmDRS255omE8WG7+49dvmBOzc0R+P4DLLfaZQm+3/ffCCy3AsstdlmCOTX/s1tmMKfmNuBnX9lOCvKxzm+z7FscbHK5vI58nnX/ZlUsNxucSdjuZgF8rLvFIUvSYFFLrn4pjA/r8g67fEEffnsEvjuA5W67LEEffmcElruB5S67LEEffo/dMoM+/F7gZ1/ZTgrysc7vtexbHGxyubyOfJ51/2ZVLLcbnEnY7nYBfKy7yyFL0mBRS65+KYwP6/J+u3xBH35fBL77gWWPA5YHIrDsAZYH7bIEffhDdssM+vCHgZ99ZTspyMc6f9iyb3GwyeXyOvLNFFbFcp/BmYTt7hPAx7oHHbIkDRa15Dp+wviwLh91wPdIBL5Hge+REL7HHPDtjcD3GPDtDeF7wgHf4xH4ngC+x0P4eGebfE/Gps7HmSnYD/kKHPDF41PnKwA+3g/5Ch3wJSLwFQJfIoSv2AFfUQS+YuArCuFL2uULxg+zIvCxfcVSYjlWqsxSu2X2qzJTlmOmyiiDIHH8SqHuOD8F8SqzHK842ORyeR35pspaH5teVgd2B8pi2XHNLMMW33NBpnKdLgQ9H3tqtULrivQ6b3+O3iYB26xL6jJ1jHnpghhXOIgxLoOQroD65qVJEMtuQSytglhGBbGsF8SyRhDLCkEsbYJY6gWx9ApiSQhi6RDE0i2IJSOIZbYglmFBLKVxOSztguKyThDLSkEsSwSxNAhi6RPEMl8QS7Mglk5BLEOCWNYKYlktiKVREMsqQSzLBLEsFsTSI4glPs0sydjEa+BJyC+F7QqMfdW1wQ9Wj+VXaX0BlFOtdYmQsqug7Eqdro5P3BdjVOUgRmhnENbZVikwVMenn6VHEMtiQSzLBLGsEsTSKIhltSCWtYJYhgSxdApiaRbEMl8QS58glgZBLEsEsawUxLJOEEu7IBYe30pgGRYUl9mCWDKCWLoFsXQIYkkIYukVxFIviKVNEMsKQSxrBLGsF8QyKoilVRDLbkEsTYJYuvLEwtcKudxKg2U67dbYtRs8E1QLdvnaaQ3Ene3XAke9XY5g7jRyqMVYHXd9uR5Y6izXhSqzwXKcVZmNlmOmymiCIHH8mD0F+Y0QryYHbbfBaLu8jnxTZcW5btPB6qr+my3XP8/H5lg2GzHFeLfodCHoa8Df2Zb9VcW16jJ5jjczsK0EbPOK0uz/cm2/Fdi5/8F5Hh2W24WKY1uE/qcDYtfuoP9JO+jnO8Eh9jUNxx/nt4JvnQ6Ov7Rx/PF6J7DwgnP80w5YcBmEdDqEpUkQy25BLNhepp1FUFxGBbGsF8TSJKi9rBEUlxWCWNoEsdQLYukVxJIQxNIhiKVbEEtGEMtsQSzDgljaBbGsE8SyUhDLEkEsfYJY5gtiaRbE0imIZUgQy1pBLKsFsTQKYlkliGWZIJbFglh6BLHEp5llX3P8Ob8JtuNrfG2gm6PT7aArCLHBv3c6QVeodVyGutZ8VvXEsjFGLq5pop1BWGdbOMd/Tnz6WXoEsSwWxLJMEMsqQSyNglhWC2JZK4hlSBBLpyCWZkEs8wWx9AliWSKIZaUglnWCWNoFsQwLYpktiCUjiKVbEEuHIJaEIJZeQSz1gljaBLGsEMSyRhALX1eQwLJeUFxGBbG0SmIR1F52C4pLkyCWrhAWy9c0B/A6JC/Gauh1TsXSbZcl+G5UVwSWbmCZa7mOVJnz7JYZzHueb7lMVcYCCBLHj9lTkD8f4rXAQZueFx9fT7yOfJ51/2bFudXMmYTtOgXwsW4usNjuC5TPPB7gstX9m42pMZuW5/UvVcVh/z0IDGwrAducWTXGNaS5SiEf7z21h9Rfm4P6azfqj9fb4LzJvrQDS7sDlg6DRZJd27HHOubFWB13bm4DFtvP06SAZTbYaXHgc2sEn1uAxfLzTZkUsDSDHcvPhAX9El/Da4J+6dSUs/oM+qU2o19iBnw+ircZhn7pdOiX2kKOg1bL8YkDk1rSYLcV+sPWkPZp+5k3ZaclQvvEdmP3mb5M0G6aIrA0AIvlZ0EzDp7J7XfwbO2E542feuYTxiKcXwfxqnVwTqk3zim8jnye1bN6Vs/qWT2rZ/WsnnX/ZlUs/PsD5zXzdi0C+FiH73yx/dsgeF9GbHw9qd+m18FvZru/0zPB71D8PZcGBraVgG2OqBzjugF+MzcbdZWEWGH9NTiov0aj/nidbeF9bay/RgcsTQbLM9fuwCb7x0Cmn9+/02z0V2adKtuW39sVXKergziqxVgdd+2hxmG/pMqstty/qDKqwCH2tRr6Oc7H9wO4fDcdl2u+mw6fxSkAlmoHLLgMQro6hGW3IJZRQSytgljWC2JZI4glI4ilXhBLtyCWSkEsSUEsCUEsOAaZbpbZguLSLohliSCWBkEs8wWxVAliaRbEUiqIpVAQy5AglrWCWJYJYukRxFItiCUliKVIEEuroLFUk6C4rBDE0iaIpVcQS40glg5BLGWCWIoFsQwLYlkniGWlIJY+QSy1glg6BbGUC2KZJYhltSCWRkEsqwSxLBbEUieIpUsQS4UglhJBLC2CWOLTzLKv9zNyfh1sZ37rC9/FiOXxPQ7eXv1OP7d6YtkFsYllYzmcxhhVOogR2hmEdbaF72esjk8/S4sglhJBLBWCWLoEsdQJYlksiGWVIJZGQSyrBbHMEsRSLoilUxBLrSCWPkEsKwWxrBPEMiyIpVgQS5kglg5BLDWCWHoFsbQJYlkhiKVJEAvfF5bAUiQoLilBLNWCWHoEsSwTxLJWEMuQIJZCQSylgliaBbFUCWKZL4ilQRDLEkEs7YJYZgtiaRA0lkoIiktSEEulIJZuQSz1glgygljWCGJZL4ilVRDLqCCW3YJYzHvfmK/G5Xy+4nvbCcg/VN9MUP/29Yy4C79wGYxN5N7XM+LTzTIqiKVVEMt6QSxrBLFkBLF0C2KpFMSSFMSSEMTS4PjcFoVltqC4tAtiWSKIpUEQy3xBLFWCWJoFsZQKYikUxDIkiGWtIJZlglh6BLFUC2JJCWIpEsTSKmgs1SQoLisEsbQJYukVxFIjiKVDEEuZIJZiQSzDgljWCWJZKYilTxBLrSCWTkEs5YJYZgliWS2IpVEQyypBLIsFsdQJYukSxFIhiKVEEEuLIJb4NLPs67lszk+ArkLr8Ht75TrdALqCEBtcTgXo+Jocl6F+z19QPZGhABjKQrh4f7THdsriE/d1HXO0MwjreE+fGcocXzeYCkuLIJYSQSwVgli6BLHUCWJZLIhllSCWRkEsqwWxzBLEUi6IpVMQS60glj5BLCsFsawTxDIsiKVYEEuZIJYOQSw1glh6BbG0CWJZIYilSRAL//aWwFIkKC4pQSzVglh6BLEsE8SyVhDLkCCWQkEspYJYmgWxVAlimS+IpUEQyxJBLO2CWGYLYmkQNJZKCIpLUhBLpSCWbkEsGUEsawSxrBfE0iqIZVQQy25BLAUGSynk8zWr4Pel1nWCrlTrukCX1Lpu0JVo3XzQzdK6HtAVa10v6Iq0rg90hVq3GHQJrcuArkDrloAurnXLQMc3o1eA7kmdXgm6J3R6Fege1+nVoHtMp7lfUOeTRw2dqvNHdHpQ/+9/ektQ52yHy+X1R4Bvr04/CjpOrwXmhw2dYn7IAfPDBjOvPwR8zP8w6Di9Dpj3GDrF/KAD5j0GM68/CHzMvwd0nF4PzA8YOsV8vwPmBwxmXr8f+Jj/AdBxegiY7zN0ivleB8z3Gcy8fi/wMf99oOP0MDDfY+gU890OmO8xmHn9buBj/ntAx+lRYL7L0CnmOx0w32Uw8/qdwMf8d4GO07sd8+01+PYafK7sPmLYfSRPdh8y7D6UJ7sPGnYfzJPd+w279+fJ7r2G3XvzZPduw+7debK7v7Xn6eo39rf2PF39xnQdR/58lB+7/nyUH7tTOY5ut2t3IAnl8xI31gchfTuw3GE5BqrM2+yW2a/K/J/lMlUZt0JMOH7MnoL8/0G8brUcrzjY5HJ5HflmCmsSdPgcBeenQHeL1pWC7r9cDuj+o3UloLtZ62aB7ib2HXT/1roi0P1L6x4H5n/q9GOg+4dO7wXd33X6UdDdqNOPgO5vOv0w6P6q0w+B7i86vQd0N+j0g6D7s04/ALo/6fT9oLtep+8D3XU6fS/o/qjT94DuDzp9N+iu1ek7QXeNTt8Buqt1+n+gu0qnCyH2V2pdAnS/17oC0F2hdXHQXR5j5Zjud1r1JNi9TKefAN2lOn0X6Pia7W2g4/tn2J55LsMtoOM5S/8FHc/Z/A/oeJ74zaDjZ1NuAh3fK/s36Hjewr9Ax/OT/gk6np/5D9CV6/TfQcfPodwIOr4v9jfQ8byAv4KO5yL9BXQ8//EG0PGc6z+Djp/z+BPo+P3C14OO77tfBzp+/uCPoON5dH8AHc+ruBZ0/DzSNaDjeylXg47vJV8FOp7DeCXo+P7370HH1/avAF1apy8HXadO/w50c3T6MtDxPQBur6r9qHbVZPm+RhAzY5CQa8zQBPdYGu2y9KeApRHs1Fu1M9CviuN79erYT8fG6rke7NbZsZvhhCquFsrvBA62lYBtXqMPynK9fa3leMfBbpGOA/PUAg9vs0HzqH6wsMpZOwjGsU0R2mSj/TpjlP4kxGQqLHXO2m12TG27DagyayyXqcqohiCZbSoF+TUQr2oH92xr4+PrideRz7N6Vs/qWT2rZ/WsntWzelbP6lk9q2f1rJ7Vs3pWz+pZZwqrYuHr5/geRd6uSQAf6/B+i+1r23ivjstW9y7uqxyz2WDVZvbeEt6PSAMD20rANgdUjXHt0VylkN8E9VcfUn91Duqv3qg/Xmdb+Kwr1l+9A5YGg+WZa3dgk/1jYKBfzQkI7p8b/ZVZp3jvtQ6OFb7PF7y3RutboE02GLrpqg88ZhpC2mmzs34m4+IeWvDYXTXUQ6NxbklAfiX0IdVVY3Vj9hcqPx2Sz4uxOu6+Jt63tvxsZdBnVkD5g2AD7ZY7aFdsN66FbVRAnDndwRNiYDuM77h3asQnbofpemOfFORXOfa50jiWKg1W1U7qoE2l4V6/7fMN+otx4fkYKcjH70vWOIgLju/SwFADddRi9Ds4rsI+sCqP46qqkHFVHfCxH9ifXJcaY3U5BjLn1zTYP0+Mm1+D8y86gaMejmfeZkC3azW/xhz3pGFf/H5nPuYEmedmnBO0ApjzNSeo3uiLMYaroJ84HsYKYePXOkPngD+D/FxuncGP4wJsL7Z/C2HfwIuxOu4cW+2wf3PQJwXzfPBcEtYfcT7P83QwfgjqvMqo8yrj/BoztqkNGT/WhZx/Kyz3jS7O6aqMMujbG4zzeQLyD4fj9QgYC7LPjVDOhpB8XnK1YxzLlTron5LGWLE0PtFuiYM2ljTGik89hwBx5vSxMFYsgWBxfEuh3fGzELhdSUi7LYXjivNTjn0uNY6rUoNVtZOjoE1tgLGi7eMc/cW48Pk5Bfn4u7bJOK7x2x14LnIx1i4z4ldmHJup2MT3yOC51P74LMvVaIx1zGtUeO0M+wS8djbbwfmyLUI/Mxvqrtkuy1JVXAsc74NgA78t3+igbpoMuy1G35yCODWFjGnaIWg4FkqH7GOONXGchudGPl+2Qnk8RimITRxjqSXsejn+lmLOarBTZdixfg7OjB+3FIDNCmBrNY5JxVHmoK7Ljf7BfJ8hPpeCv89PTY3FjOu1E49dQ6f42xzwtxv8vN4GddphtMtiiK8dluw8/Sh9B7Yv2/2YKrPFbpn99vu4lRtVGficBcevJeTciddPmxy0oxajHbWEnJ/t2h3YrMponMT/xhCOxjz63+jM7vJNqoyGSfxvCOFoyKP/Dc7sLh9SZdRP4n99CEd9Hv13d79pRXAerJvE/7oQjro8+l+3j7FMLtaGaWa1b3dp0FfXTuJ/bQhHbR79r3VmN7NclVEzif81IRw1efS/xpndA4PXZlZP4n++5p/sy/9qZ3YzW1QZVZP4XxXCUZVH/6uc2V0ZtP/KSfyvDOGozKP/lc7srtygyqiYxP+KEI6KPPpf4czuxuD1uuWT+F8ewlGeR//LndndcKAqo2wS/8tCOMry6H+ZM7sDQf2nJvE/FcKRyqP/KWd2Nwfjn9JJ/C8N4SjNo/+l7uwG57/kJP4nQziSefQ/6czu5uC3Wskk/peEcJTk0f8SZ3Y3BvU/axL/Z4VwzMqj/7Oc2R0KrtUUT+J/cQhHcR79L3Zmd3lQ/0WT+F8UwlGUR/+LnNldEpz/CifxvzCEozCP/hc6s7tlqSojMYn/iRCORB79TzizuyE4/gsm8b8ghKMgj/4XOLM7EPz+j0/ifzyEI55H/+PO7C7fmDWQ2/9YCEcsj/7H3NkN/H8yltv/p/KB48lY/vxnW/btbg76/ydiuf3nfOR4Io/+P+HObtD/PR7L7T/nI8fjefT/cWd2Vwb932Ox3P5zPnI8lkf/H3Nmd+MGVcbeSfznfOTYm0f/9zqzuzQY/z46if+cjxyP5tF/5GsJOVfxO0eDb2ga/IrV8verlqoyH7bsvyqD31us5qHw3A62k4D85dVj2x2o00nwmeetqPzVIfm8GKvj5nFwzJSvlr9LFcw1fQDKHwQbaNflt6XiWtgG6xOQPphfyhsb/559ji9+Q2tPyHaYbjH2SUH+Hsc+7+vbBGxLtZNV0Ka4zbg4ztFfjEsrxIXzcV6T7eNNFW1+K4IZHgaWTqM/UccRt9FO4NvjgG9f39DYA3ysw/elsx/Yn2yEeW2dWo/fTUzr9Bwop9vQKT/nOfCT7XC5vD4P+Pi9zd355RuYKt9cg0+xLLAcqyTY5CVXH74AWOZbZlFl9tgtM5g3sxD42Ve2k4J8fO5loWXf4mCTy+V15OsJYeX3qeN3iHuA1XLMAta5BuvcELt9eYgR9yt9ju32Gna7DLvqOMF6Ukuu46QXeA+wzKvKXGS3zGD8tBiYB8FGF+j7HcR+McQzDjZYn4D0aTB+6h9LPnWuYWZ1rPSFbIfphcY+Kcjvc+zzIuAYhHW2pc6vO2HMZLnNB/XdZzDwehfoF4XEqw/ixfndoOMxAPaxc4wyklAOnmstt+tMLj+x3lnXC3yLQvgW2+UbyNUWFgMf6w4AFhf9oMnC5x7sBxuN+AXPkgFXwjJXsS7XZpn4jRhecvXnxfC/yDKL+raMHkrHdo3s2LnhuC1HbNmwGa9UFxqIBYCGaQ49fsamEHT8GZsi0PH+s0DH5ZRAngvX0Tcut9BgLAY2W3bxc0C85Kr+WcBiuymqGPPngHT1H71z68gWrP8igzGs/lVewtiO663QMjPa4nJ5nW0pv/iTRids2PT65+08bnT7luGRXRhos2HHDYfUgpWFjZm3KzKctdxYlkprLPwNp00btm07fHTjtq2bDh4d3jSydcdwWJPhiGF1hXUZuO2+uookeMY6LqsEdNgNcUTMiFkLST2Uyc0noZ0pio01iZLY2Ce6gimIsWz7VJ/YUk/Kqqd41YhLhVd9EqsOyv25/q9sqU9eqVOg+qSV+oSV+mSVujyiHv1Tr05Rj+KqIVA6lv35ooYPakilfkKpYZL6Wad+Oquf0mqIpIZEatihTu3qNKtOq+rUr4aC6trWAMkSEjWvQN1bU/OLV5CoeZbqXsuzSFaRHETybJLnkDxXx/d5JM8neQHJC0leRHIwyWqSQ0jWkBxK8mKSl5C8lORlJIeRHE6yluQIkiNJXk5yFMkrSI4mWUfySpJXkbya5BiS15C8lmQ9ybGx7LBA3Q9Vzy+p+2Lq3sAQyXEkryPZSnI8yetJtpFsj2U/Ub+D5ASSN5DsJNlFMhLLfgr+RJKTSE4mOYXkjSRvIjmV5DSSN5O8heR0kreSvI3k7SRnkLyD5EySd5K8i+TdJO8heS/J+0jeT/IBkg+SfIjkwyQfiWU/8f5Rko+RfJzkEySfJPkUyVkknyY5m+QzJJ8lOYfkcySfJzmX5DySL5B8keRLJOeTXEDyZZKvkHyV5GskXyf5Bsk3Sb5F8m2S75B8l+R7JBeSfJ/kByQ/JPkRyY9JfkLyU5KfxbJt9RckF5H8kuRikl+R/JrkEpLfkPw2lv1c2WWx7OfNLo9lP4emPpOmPp+mPqumPremPsOmPs/GBzIexDx1j3+ibxgZ2bL9hJH0yI709tFtI1tP2HZK+qStI69L7zhxy86hbTtOwp3//XR2vkWvzJ6484bNm/e93yN6hT94t2Z485aT0ztGR9I7htIbd4wObx53bjpae32QXj8ye3JO79q2YyTdnx6mv9QD7zhpy+ZFaczbRS7sGknvGtmwcyQ9tHPH9nRmEZZ7VKmbco+pfBoxzVQ9jZ2XV029Qv4Pa1hbvP4WAwA=",
+      "debug_symbols": "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"
+    },
+    {
+      "name": "compute_note_hash_and_nullifier",
+      "function_type": "Unconstrained",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::AztecAddress",
+              "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+            },
+            "visibility": "private"
+          },
+          { "name": "nonce", "type": { "kind": "field" }, "visibility": "private" },
+          { "name": "storage_slot", "type": { "kind": "field" }, "visibility": "private" },
+          {
+            "name": "serialized_note",
+            "type": { "kind": "array", "length": 3, "type": { "kind": "field" } },
+            "visibility": "private"
+          }
+        ],
+        "param_witnesses": {
+          "contract_address": [{ "start": 0, "end": 1 }],
+          "nonce": [{ "start": 1, "end": 2 }],
+          "serialized_note": [{ "start": 3, "end": 6 }],
+          "storage_slot": [{ "start": 2, "end": 3 }]
+        },
+        "return_type": {
+          "abi_type": { "kind": "array", "length": 4, "type": { "kind": "field" } },
+          "visibility": "public"
+        },
+        "return_witnesses": [6, 7, 8, 9]
+      },
+      "bytecode": "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",
+      "debug_symbols": "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"
+    },
+    {
+      "name": "broadcast",
+      "function_type": "Open",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::abi::PublicContextInputs",
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::call_context::CallContext",
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "storage_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "function_selector",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                          "fields": [
+                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                          ]
+                        }
+                      },
+                      { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                      { "name": "is_static_call", "type": { "kind": "boolean" } },
+                      { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                      {
+                        "name": "start_side_effect_counter",
+                        "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "block_header",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                    "fields": [
+                      { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                      { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_tree_root", "type": { "kind": "field" } },
+                      { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                      { "name": "archive_root", "type": { "kind": "field" } },
+                      { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                      { "name": "global_variables_hash", "type": { "kind": "field" } }
+                    ]
+                  }
+                },
+                {
+                  "name": "public_global_variables",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::abi::PublicGlobalVariables",
+                    "fields": [
+                      { "name": "chain_id", "type": { "kind": "field" } },
+                      { "name": "version", "type": { "kind": "field" } },
+                      { "name": "block_number", "type": { "kind": "field" } },
+                      { "name": "timestamp", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "owner",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::AztecAddress",
+              "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+            },
+            "visibility": "private"
+          }
+        ],
+        "param_witnesses": { "inputs": [{ "start": 0, "end": 19 }], "owner": [{ "start": 19, "end": 20 }] },
+        "return_type": {
+          "abi_type": {
+            "kind": "struct",
+            "path": "aztec::protocol_types::abis::public_circuit_public_inputs::PublicCircuitPublicInputs",
+            "fields": [
+              {
+                "name": "call_context",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::call_context::CallContext",
+                  "fields": [
+                    {
+                      "name": "msg_sender",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "storage_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "function_selector",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                        "fields": [{ "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }]
+                      }
+                    },
+                    { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                    { "name": "is_static_call", "type": { "kind": "boolean" } },
+                    { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                    {
+                      "name": "start_side_effect_counter",
+                      "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                    }
+                  ]
+                }
+              },
+              { "name": "args_hash", "type": { "kind": "field" } },
+              { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+              {
+                "name": "contract_storage_update_requests",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::storage_update_request::StorageUpdateRequest",
+                    "fields": [
+                      { "name": "storage_slot", "type": { "kind": "field" } },
+                      { "name": "old_value", "type": { "kind": "field" } },
+                      { "name": "new_value", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "contract_storage_reads",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::storage_read::StorageRead",
+                    "fields": [
+                      { "name": "storage_slot", "type": { "kind": "field" } },
+                      { "name": "current_value", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "public_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              {
+                "name": "new_commitments",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_nullifiers",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "note_hash", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              {
+                "name": "unencrypted_logs_hash",
+                "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
+              },
+              { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
+              {
+                "name": "block_header",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                  "fields": [
+                    { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                    { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_tree_root", "type": { "kind": "field" } },
+                    { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                    { "name": "archive_root", "type": { "kind": "field" } },
+                    { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                    { "name": "global_variables_hash", "type": { "kind": "field" } }
+                  ]
+                }
+              },
+              {
+                "name": "prover_address",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::address::AztecAddress",
+                  "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                }
+              }
+            ]
+          },
+          "visibility": "public"
+        },
+        "return_witnesses": [
+          20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+          47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+          74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+          101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+          123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
+          145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
+          167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
+          189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209
+        ]
+      },
+      "bytecode": "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",
+      "debug_symbols": "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"
+    },
+    {
+      "name": "constructor",
+      "function_type": "Secret",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::abi::PrivateContextInputs",
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::call_context::CallContext",
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "storage_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "function_selector",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                          "fields": [
+                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                          ]
+                        }
+                      },
+                      { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                      { "name": "is_static_call", "type": { "kind": "boolean" } },
+                      { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                      {
+                        "name": "start_side_effect_counter",
+                        "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "block_header",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                    "fields": [
+                      { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                      { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_tree_root", "type": { "kind": "field" } },
+                      { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                      { "name": "archive_root", "type": { "kind": "field" } },
+                      { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                      { "name": "global_variables_hash", "type": { "kind": "field" } }
+                    ]
+                  }
+                },
+                {
+                  "name": "contract_deployment_data",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                    "fields": [
+                      {
+                        "name": "deployer_public_key",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                          "fields": [
+                            { "name": "x", "type": { "kind": "field" } },
+                            { "name": "y", "type": { "kind": "field" } }
+                          ]
+                        }
+                      },
+                      { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                      { "name": "function_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_address_salt", "type": { "kind": "field" } },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "private_global_variables",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::abi::PrivateGlobalVariables",
+                    "fields": [
+                      { "name": "chain_id", "type": { "kind": "field" } },
+                      { "name": "version", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          }
+        ],
+        "param_witnesses": { "inputs": [{ "start": 0, "end": 23 }] },
+        "return_type": {
+          "abi_type": {
+            "kind": "struct",
+            "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
+            "fields": [
+              {
+                "name": "call_context",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::call_context::CallContext",
+                  "fields": [
+                    {
+                      "name": "msg_sender",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "storage_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "function_selector",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                        "fields": [{ "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }]
+                      }
+                    },
+                    { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                    { "name": "is_static_call", "type": { "kind": "boolean" } },
+                    { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                    {
+                      "name": "start_side_effect_counter",
+                      "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                    }
+                  ]
+                }
+              },
+              { "name": "args_hash", "type": { "kind": "field" } },
+              { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+              {
+                "name": "read_requests",
+                "type": {
+                  "kind": "array",
+                  "length": 32,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_commitments",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_nullifiers",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "note_hash", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "private_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              {
+                "name": "public_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              { "name": "end_side_effect_counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
+              { "name": "encrypted_logs_hash", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              {
+                "name": "unencrypted_logs_hash",
+                "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
+              },
+              { "name": "encrypted_log_preimages_length", "type": { "kind": "field" } },
+              { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
+              {
+                "name": "block_header",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                  "fields": [
+                    { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                    { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_tree_root", "type": { "kind": "field" } },
+                    { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                    { "name": "archive_root", "type": { "kind": "field" } },
+                    { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                    { "name": "global_variables_hash", "type": { "kind": "field" } }
+                  ]
+                }
+              },
+              {
+                "name": "contract_deployment_data",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                  "fields": [
+                    {
+                      "name": "deployer_public_key",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                        "fields": [
+                          { "name": "x", "type": { "kind": "field" } },
+                          { "name": "y", "type": { "kind": "field" } }
+                        ]
+                      }
+                    },
+                    { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                    { "name": "function_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_address_salt", "type": { "kind": "field" } },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    }
+                  ]
+                }
+              },
+              { "name": "chain_id", "type": { "kind": "field" } },
+              { "name": "version", "type": { "kind": "field" } }
+            ]
+          },
+          "visibility": "public"
+        },
+        "return_witnesses": [
+          24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+          51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
+          78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
+          104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
+          126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
+          148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
+          170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+          192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212
+        ]
+      },
+      "bytecode": "H4sIAAAAAAAA/+Xd5XNUVxzG8U2yu6l7CU5wh9XsXdzdqtQLWzb1lir1UupOlXopdaeutLTUvcAfxPMMm5m8gFeczHDme2eeyUxe3NnP3rtXz/n9dqdSqR2pvUuT0qy0KO3d/udlRuNv7sCWfFrrSO9jvcVcR6lUrxTq+WJ+da5QrSXlXKlc60jySb6clNcUkmKxnpSSSrVWreSq+VKxnu8sV4udjRWnw33GXE+4M1pHpgfcmYPcndU6sj3gzgZ0d+33rd32+9R+9v8D/dxtgbdX19IceLuFNPeOxNwU0NwnEnNzQHPfSMwtAc39IjGnA5r7R2LOBDQPiMScDWgeGIm5NaB5UCTmtoDmdqB5MNA8BGgeCjQPA5qHA80jgOaRQPMooHk00DwGaB4LNI8DmscDzROA5olAcw5ozgPNBaC5CDSXgOYy0NwBNFeA5gRorgLNk4DmyUDzFKB5KtA8DWieDjTPAJpnAs2zgObZQPMcoHku0DwPaJ4PNC8AmhcCzYuA5sVA8xKgeSnQvAxoXg40rwCaTwKaTwaaTwGaTwWaTwOaTweaVwLNZwDNZwLNZwHNZwPN5wDN5wLN5wHN5wPNq4Dm1UBzDWi+AGheAzTXgeZOoPlCoPkioPlioPkSoPlSoPkyoPlyoPkKoPlKoHkt0HwV0Hw10HwN0Hwt0Hwd0Hw90LwOaL4BaL4RaL4JaL4ZaL4FaL4VaL4NaL4daF4PNN8BNG8Amu8Emu8Cmu8Gmu8Bmu8Fmu8Dmu8Hmh8Amh8Emh8Cmh8Gmh8Bmh8FmjcCzY8BzY8DzU8AzU8CzU8BzU8DzZuA5meA5meB5ueA5ueB5heA5heB5peA5peB5s1A8ytA8xag+VWg+TWg+XWg+Q2g+U2g+S2g+W2g+R2g+V2g+T2g+X2g+QOg+UOgeSvQ/BHQ/DHQ/AnQ/CnQ/BnQ/DnQ/AXQ/CXQ/BXQ/DXQ/A3Q/C3QvA1o/i4Sc2tA8/fA7bwdaP4BaP4RaN4BNP8ENP8cifmQgOZfIjEfGtD8ayTmwwKaf4vEfHhA8++RmI8IaP4jEvORAc1/RmI+KqD5r0jMRwc0/x2J+ZiA5n8iMR8b0PxvJObjApr/i8R8fEDz/5GYTwho3hmJ+cSA5l2RmHsFNO8OaG7rZm5quFuUtJJRsoqfX/q+0PdJvm/wdbSvK32d5esOn4d9XvJx2sct/469X3s79+q2/m2Nv72VPkpfpZ/SXxmgDFQGKe3KYGWIMlQZpgxXRigjlVHKaGWMMlYZp4xXJigT/Z0oeaXg71opKWWlQ6koiVJVJimTlSnKVGWaMr3x3c5UZimzlTnKXGWeMl9ZoCxUFimLlSXKUmWZslxZobj/vPuxuz+5+3W7f7X7Oa9U3O/X/W/dD9b9Ud0v1P0z3U/S/RVXKe6/V1Pcn839yty/y/2s3N/J/Y7c/8f9cNwfxv1S3D/E/TTcX2Kt4v4Drsfv+vSu1+765a7nvU5xvWfXP3Y9YNfHdb1Y1091PVHX11yvuP7iBsX1+VyvzvXbXM/M9b1c78r1n1wPyfWBXC/H9WNcT8X1RTYqrj/hegyuT+D5+p6/7vncmxTP9/X8V88H9fxIzxf0/DnPJ/P8qs2K599sUTw/w/MVPH7f49k9vtvjnT3+1+NhPT7U4yU9ftDj6Ty+bKvi8Ucej+PxKR6v4fELfp/v99t+3+v3n34f6Pdjfl/kfdPvE/x8fbvi569+Hunnc35e5ec3fp7h+3vf7/r+z/dDvj/w9bKvH3095esLn299/vHx2Mcn/167lj1HMZVAULsAAA==",
+      "debug_symbols": "q1bKyU9OLMnMzytWsqqurQUA"
+    },
+    {
+      "name": "recreate_note",
+      "function_type": "Secret",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::abi::PrivateContextInputs",
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::call_context::CallContext",
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "storage_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "function_selector",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                          "fields": [
+                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                          ]
+                        }
+                      },
+                      { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                      { "name": "is_static_call", "type": { "kind": "boolean" } },
+                      { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                      {
+                        "name": "start_side_effect_counter",
+                        "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "block_header",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                    "fields": [
+                      { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                      { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_tree_root", "type": { "kind": "field" } },
+                      { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                      { "name": "archive_root", "type": { "kind": "field" } },
+                      { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                      { "name": "global_variables_hash", "type": { "kind": "field" } }
+                    ]
+                  }
+                },
+                {
+                  "name": "contract_deployment_data",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                    "fields": [
+                      {
+                        "name": "deployer_public_key",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                          "fields": [
+                            { "name": "x", "type": { "kind": "field" } },
+                            { "name": "y", "type": { "kind": "field" } }
+                          ]
+                        }
+                      },
+                      { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                      { "name": "function_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_address_salt", "type": { "kind": "field" } },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "private_global_variables",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::abi::PrivateGlobalVariables",
+                    "fields": [
+                      { "name": "chain_id", "type": { "kind": "field" } },
+                      { "name": "version", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "owner",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::AztecAddress",
+              "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+            },
+            "visibility": "private"
+          },
+          { "name": "index", "type": { "kind": "integer", "sign": "unsigned", "width": 32 }, "visibility": "private" }
+        ],
+        "param_witnesses": {
+          "index": [{ "start": 24, "end": 25 }],
+          "inputs": [{ "start": 0, "end": 23 }],
+          "owner": [{ "start": 23, "end": 24 }]
+        },
+        "return_type": {
+          "abi_type": {
+            "kind": "struct",
+            "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
+            "fields": [
+              {
+                "name": "call_context",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::call_context::CallContext",
+                  "fields": [
+                    {
+                      "name": "msg_sender",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "storage_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "function_selector",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                        "fields": [{ "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }]
+                      }
+                    },
+                    { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                    { "name": "is_static_call", "type": { "kind": "boolean" } },
+                    { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                    {
+                      "name": "start_side_effect_counter",
+                      "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                    }
+                  ]
+                }
+              },
+              { "name": "args_hash", "type": { "kind": "field" } },
+              { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+              {
+                "name": "read_requests",
+                "type": {
+                  "kind": "array",
+                  "length": 32,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_commitments",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_nullifiers",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "note_hash", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "private_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              {
+                "name": "public_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              { "name": "end_side_effect_counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
+              { "name": "encrypted_logs_hash", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              {
+                "name": "unencrypted_logs_hash",
+                "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
+              },
+              { "name": "encrypted_log_preimages_length", "type": { "kind": "field" } },
+              { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
+              {
+                "name": "block_header",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                  "fields": [
+                    { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                    { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_tree_root", "type": { "kind": "field" } },
+                    { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                    { "name": "archive_root", "type": { "kind": "field" } },
+                    { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                    { "name": "global_variables_hash", "type": { "kind": "field" } }
+                  ]
+                }
+              },
+              {
+                "name": "contract_deployment_data",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                  "fields": [
+                    {
+                      "name": "deployer_public_key",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                        "fields": [
+                          { "name": "x", "type": { "kind": "field" } },
+                          { "name": "y", "type": { "kind": "field" } }
+                        ]
+                      }
+                    },
+                    { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                    { "name": "function_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_address_salt", "type": { "kind": "field" } },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    }
+                  ]
+                }
+              },
+              { "name": "chain_id", "type": { "kind": "field" } },
+              { "name": "version", "type": { "kind": "field" } }
+            ]
+          },
+          "visibility": "public"
+        },
+        "return_witnesses": [
+          6072, 6073, 6074, 6075, 6076, 6077, 6078, 6079, 6080, 6081, 6082, 6083, 6084, 6085, 6086, 6087, 6088, 6089,
+          6090, 6091, 6092, 6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100, 6101, 6102, 6103, 6104, 6105, 6106, 6107,
+          6108, 6109, 6110, 6111, 6112, 6113, 6114, 6115, 6116, 6117, 6118, 6119, 6120, 6121, 6122, 6123, 6124, 6125,
+          6126, 6127, 6128, 6129, 6130, 6131, 6132, 6133, 6134, 6135, 6136, 6137, 6138, 6139, 6140, 6141, 6142, 6143,
+          6144, 6145, 6146, 6147, 6148, 6149, 6150, 6151, 6152, 6153, 6154, 6155, 6156, 6157, 6158, 6159, 6160, 6161,
+          6162, 6163, 6164, 6165, 6166, 6167, 6168, 6169, 6170, 6171, 6172, 6173, 6174, 6175, 6176, 6177, 6178, 6179,
+          6180, 6181, 6182, 6183, 6184, 6185, 6186, 6187, 6188, 6189, 6190, 6191, 6192, 6193, 6194, 6195, 6196, 6197,
+          6198, 6199, 6200, 6201, 6202, 6203, 6204, 6205, 6206, 6207, 6208, 6209, 6210, 6211, 6212, 6213, 6214, 6215,
+          6216, 6217, 6218, 6219, 6220, 6221, 6222, 6223, 6224, 6225, 6226, 6227, 6228, 6229, 6230, 6231, 6232, 6233,
+          6234, 6235, 6236, 6237, 6238, 6239, 6240, 6241, 6242, 6243, 6244, 6245, 6246, 6247, 6248, 6249, 6250, 6251,
+          6252, 6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260
+        ]
+      },
+      "bytecode": "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",
+      "debug_symbols": "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"
+    },
+    {
+      "name": "create_note",
+      "function_type": "Secret",
+      "is_internal": false,
+      "abi": {
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::abi::PrivateContextInputs",
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::call_context::CallContext",
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "storage_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::AztecAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      },
+                      {
+                        "name": "function_selector",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                          "fields": [
+                            { "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                          ]
+                        }
+                      },
+                      { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                      { "name": "is_static_call", "type": { "kind": "boolean" } },
+                      { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                      {
+                        "name": "start_side_effect_counter",
+                        "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "block_header",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                    "fields": [
+                      { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                      { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_tree_root", "type": { "kind": "field" } },
+                      { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                      { "name": "archive_root", "type": { "kind": "field" } },
+                      { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                      { "name": "global_variables_hash", "type": { "kind": "field" } }
+                    ]
+                  }
+                },
+                {
+                  "name": "contract_deployment_data",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                    "fields": [
+                      {
+                        "name": "deployer_public_key",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                          "fields": [
+                            { "name": "x", "type": { "kind": "field" } },
+                            { "name": "y", "type": { "kind": "field" } }
+                          ]
+                        }
+                      },
+                      { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                      { "name": "function_tree_root", "type": { "kind": "field" } },
+                      { "name": "contract_address_salt", "type": { "kind": "field" } },
+                      {
+                        "name": "portal_contract_address",
+                        "type": {
+                          "kind": "struct",
+                          "path": "aztec::protocol_types::address::EthAddress",
+                          "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "name": "private_global_variables",
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::abi::PrivateGlobalVariables",
+                    "fields": [
+                      { "name": "chain_id", "type": { "kind": "field" } },
+                      { "name": "version", "type": { "kind": "field" } }
+                    ]
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "owner",
+            "type": {
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::AztecAddress",
+              "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+            },
+            "visibility": "private"
+          },
+          { "name": "value", "type": { "kind": "field" }, "visibility": "private" }
+        ],
+        "param_witnesses": {
+          "inputs": [{ "start": 0, "end": 23 }],
+          "owner": [{ "start": 23, "end": 24 }],
+          "value": [{ "start": 24, "end": 25 }]
+        },
+        "return_type": {
+          "abi_type": {
+            "kind": "struct",
+            "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
+            "fields": [
+              {
+                "name": "call_context",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::call_context::CallContext",
+                  "fields": [
+                    {
+                      "name": "msg_sender",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "storage_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::AztecAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    },
+                    {
+                      "name": "function_selector",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::abis::function_selector::FunctionSelector",
+                        "fields": [{ "name": "inner", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }]
+                      }
+                    },
+                    { "name": "is_delegate_call", "type": { "kind": "boolean" } },
+                    { "name": "is_static_call", "type": { "kind": "boolean" } },
+                    { "name": "is_contract_deployment", "type": { "kind": "boolean" } },
+                    {
+                      "name": "start_side_effect_counter",
+                      "type": { "kind": "integer", "sign": "unsigned", "width": 32 }
+                    }
+                  ]
+                }
+              },
+              { "name": "args_hash", "type": { "kind": "field" } },
+              { "name": "return_values", "type": { "kind": "array", "length": 4, "type": { "kind": "field" } } },
+              {
+                "name": "read_requests",
+                "type": {
+                  "kind": "array",
+                  "length": 32,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_commitments",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffect",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "new_nullifiers",
+                "type": {
+                  "kind": "array",
+                  "length": 16,
+                  "type": {
+                    "kind": "struct",
+                    "path": "aztec::protocol_types::abis::side_effect::SideEffectLinkedToNoteHash",
+                    "fields": [
+                      { "name": "value", "type": { "kind": "field" } },
+                      { "name": "note_hash", "type": { "kind": "field" } },
+                      { "name": "counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } }
+                    ]
+                  }
+                }
+              },
+              {
+                "name": "private_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              {
+                "name": "public_call_stack_hashes",
+                "type": { "kind": "array", "length": 4, "type": { "kind": "field" } }
+              },
+              { "name": "new_l2_to_l1_msgs", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              { "name": "end_side_effect_counter", "type": { "kind": "integer", "sign": "unsigned", "width": 32 } },
+              { "name": "encrypted_logs_hash", "type": { "kind": "array", "length": 2, "type": { "kind": "field" } } },
+              {
+                "name": "unencrypted_logs_hash",
+                "type": { "kind": "array", "length": 2, "type": { "kind": "field" } }
+              },
+              { "name": "encrypted_log_preimages_length", "type": { "kind": "field" } },
+              { "name": "unencrypted_log_preimages_length", "type": { "kind": "field" } },
+              {
+                "name": "block_header",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::abis::block_header::BlockHeader",
+                  "fields": [
+                    { "name": "note_hash_tree_root", "type": { "kind": "field" } },
+                    { "name": "nullifier_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_tree_root", "type": { "kind": "field" } },
+                    { "name": "l1_to_l2_message_tree_root", "type": { "kind": "field" } },
+                    { "name": "archive_root", "type": { "kind": "field" } },
+                    { "name": "public_data_tree_root", "type": { "kind": "field" } },
+                    { "name": "global_variables_hash", "type": { "kind": "field" } }
+                  ]
+                }
+              },
+              {
+                "name": "contract_deployment_data",
+                "type": {
+                  "kind": "struct",
+                  "path": "aztec::protocol_types::contrakt::deployment_data::ContractDeploymentData",
+                  "fields": [
+                    {
+                      "name": "deployer_public_key",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::grumpkin_point::GrumpkinPoint",
+                        "fields": [
+                          { "name": "x", "type": { "kind": "field" } },
+                          { "name": "y", "type": { "kind": "field" } }
+                        ]
+                      }
+                    },
+                    { "name": "constructor_vk_hash", "type": { "kind": "field" } },
+                    { "name": "function_tree_root", "type": { "kind": "field" } },
+                    { "name": "contract_address_salt", "type": { "kind": "field" } },
+                    {
+                      "name": "portal_contract_address",
+                      "type": {
+                        "kind": "struct",
+                        "path": "aztec::protocol_types::address::EthAddress",
+                        "fields": [{ "name": "inner", "type": { "kind": "field" } }]
+                      }
+                    }
+                  ]
+                }
+              },
+              { "name": "chain_id", "type": { "kind": "field" } },
+              { "name": "version", "type": { "kind": "field" } }
+            ]
+          },
+          "visibility": "public"
+        },
+        "return_witnesses": [
+          46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+          73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+          100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+          122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+          144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
+          166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
+          188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
+          210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
+          232, 233, 234
+        ]
+      },
+      "bytecode": "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",
+      "debug_symbols": "7ZjdbhoxEIXfxdcIzdjj+eFVqlygNpUiRaQq3CHevQtdex1q4XRXVLsNVwjpjP35eOyZ9dG9vn3dHl7ednu3ObroNl+Obv9juzv/2x+2Pw9uAyv3vPvW/Z5W7vvL67PbBDut/pB5gNgrPXjJYgo1cSBKYgLMYkSsqBFM0tiIcJ6+0D+tHC+UW/4ZN4kmcQw6lVtr3CiS0FEs3KY3n7QmfmC3MTQ2KxqEyTgIJMMU1AAKaEkcuJE0pnlgKAeWCzkultwvljwslpzq5JzJFbQxPiUW0+HYIUtFK5QuMIlUaO3CEiezdNZpdhHtHc15Br77DHL3GXT6DKA+z+ChsWddsmU1FTtM1Q32nDa4uINVK1LO1zXTcDjMV6QdQei1AUneJU4FmGI2kAxb6mYpsP/F8JiIBaBhuE9nOhSj2qg2w8Oc/VNJ/lmRhZ1/Z3JcCrlek/s5k1vM5GaNnFVJrTobFOPCZZnhcyyT5rxMBLGhXunthQbmZEpgi4272XNMHJ5FG+oI2ItjHI4yx4uF8WHhBywUzCUiSmnhzbYSQyjGhVFFgh/785H9yV8UWpTwPsXlYeFUC2fdWy/Dwll3y4uwMMy6Yb6rhZrfNzW2PvMCp4pCxVuC9M8a62rBtwF9WObv1wcP6/ozTrRU6BiLzyZKQTQmqEpHGnMDM1RI6XvAdfV+D9lgQr4+i7TWETE2Iqb+XtoKwr8NCp11VRsoHw4yvUqGc5COCaoaEfMmcfFp3GXr0+n0Cw=="
+    }
+  ],
+  "events": [],
+  "file_map": {
+    "18": {
+      "source": "use crate::grumpkin_scalar::GrumpkinScalar;\nuse crate::scalar_mul::fixed_base_embedded_curve;\n\npub fn grumpkin_fixed_base(scalar: GrumpkinScalar) -> [Field; 2] {\n    // TODO: this should use both the low and high limbs to do the scalar multiplication\n    fixed_base_embedded_curve(scalar.low, scalar.high)\n}\n",
+      "path": "std/grumpkin_scalar_mul.nr"
+    },
+    "28": {
+      "source": "struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::unsafe::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<U, Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n",
+      "path": "std/option.nr"
+    },
+    "39": {
+      "source": "// A contract used for running benchmarks.\n// We should try to change this contract as little as possible, since any modification\n// would alter the metrics we're capturing in the benchmarks, and we want to keep the\n// subject being tested as unmodified as possible so we can detect metric changes that\n// arise from code changes.\n\ncontract Benchmarking {\n    use dep::value_note::{\n        utils::{increment, decrement},\n        value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},\n    };\n\n    use dep::aztec::{\n        protocol_types::{\n            abis::function_selector::FunctionSelector,\n            address::AztecAddress,\n        },\n        context::{Context},\n        note::{utils as note_utils, note_getter_options::NoteGetterOptions, note_header::NoteHeader},\n        log::emit_unencrypted_log,\n        state_vars::{map::Map, public_state::PublicState, set::Set},\n        types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},\n    };\n\n    struct Storage {\n        notes: Map<AztecAddress, Set<ValueNote, VALUE_NOTE_LEN>>,\n        balances: Map<AztecAddress, PublicState<Field, FIELD_SERIALIZED_LEN>>,\n    }\n\n    impl Storage {\n        fn init(context: Context) -> pub Self {\n            Storage {\n                notes: Map::new(context, 1, |context, slot| { Set::new(context, slot, ValueNoteMethods) }),\n                balances: Map::new(context, 2, |context, slot| { PublicState::new(context, slot, FieldSerializationMethods) }),\n            }\n        }\n    }\n\n    #[aztec(private)]\n    fn constructor() {}\n\n    // Creates a new value note for the target owner. Use this method to seed an initial set of notes.\n    #[aztec(private)]\n    fn create_note(owner: AztecAddress, value: Field) {\n        increment(storage.notes.at(owner), value, owner);\n    }\n\n    // Deletes a note at a specific index in the set and creates a new one with the same value.\n    // We explicitly pass in the note index so we can ensure we consume different notes when sending\n    // multiple txs that will land on the same block.\n    // See https://discourse.aztec.network/t/utxo-concurrency-issues-for-private-state/635\n    // by @rahul-kothari for a full explanation on why this is needed.\n    #[aztec(private)]\n    fn recreate_note(owner: AztecAddress, index: u32) {\n        let owner_notes = storage.notes.at(owner);\n        let getter_options = NoteGetterOptions::new().set_limit(1).set_offset(index);\n        let notes = owner_notes.get_notes(getter_options);\n        let note = notes[0].unwrap_unchecked();\n        owner_notes.remove(note);\n        increment(owner_notes, note.value, owner);\n    }\n\n    // Reads and writes to public storage and enqueues a call to another public function.\n    #[aztec(public)]\n    fn increment_balance(owner: AztecAddress, value: Field) {\n        let current = storage.balances.at(owner).read();\n        storage.balances.at(owner).write(current + value);\n        let _callStackItem1 = context.call_public_function(\n            context.this_address(),\n            FunctionSelector::from_signature(\"broadcast((Field))\"),\n            [owner.to_field()]\n        );\n    }\n\n    // Emits a public log.\n    #[aztec(public)]\n    fn broadcast(owner: AztecAddress) {\n        emit_unencrypted_log(&mut context, storage.balances.at(owner).read());\n    }\n\n    unconstrained fn compute_note_hash_and_nullifier(\n        contract_address: AztecAddress,\n        nonce: Field,\n        storage_slot: Field,\n        serialized_note: [Field; VALUE_NOTE_LEN]\n    ) -> pub [Field; 4] {\n        let note_header = NoteHeader::new(contract_address, nonce, storage_slot);\n        note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, serialized_note)\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-contracts/contracts/benchmarking_contract/src/main.nr"
+    },
+    "40": {
+      "source": "use crate::{\n    abi::{\n        PrivateContextInputs,\n        PublicContextInputs,\n    },\n    key::nullifier_key::validate_nullifier_key_against_address,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        public_call::call_public_function_internal,\n        enqueue_public_function_call::enqueue_public_function_call_internal,\n        context::get_portal_address,\n        get_block_header::get_block_header,\n        nullifier_key::get_nullifier_key_pair,\n    },\n    types::vec::BoundedVec,\n    utils::Reader,\n};\nuse dep::protocol_types::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_data::FunctionData,\n        function_selector::FunctionSelector,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n        call_stack_item::PrivateCallStackItem,\n        call_stack_item::PublicCallStackItem,\n        side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n    },\n    address::{\n        AztecAddress,\n        EthAddress,\n    },\n    constants::{\n        MAX_NEW_COMMITMENTS_PER_CALL,\n        MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NEW_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n        MAX_PUBLIC_DATA_READS_PER_CALL,\n        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n        MAX_READ_REQUESTS_PER_CALL,\n        NUM_FIELDS_PER_SHA256,\n        RETURN_VALUES_LENGTH,\n    },\n    contrakt::{\n        deployment_data::ContractDeploymentData,\n        storage_read::StorageRead,\n        storage_update_request::StorageUpdateRequest,\n    },\n    hash::hash_args,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::{\n    grumpkin_scalar::GrumpkinScalar,\n    option::Option,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n    // docs:start:private-context\n    inputs: PrivateContextInputs,\n    side_effect_counter: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    read_requests: BoundedVec<SideEffect, MAX_READ_REQUESTS_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    private_call_stack_hashes : BoundedVec<Field, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    public_call_stack_hashes : BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n    new_l2_to_l1_msgs : BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    block_header: BlockHeader,\n\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    // encrypted_logs_preimages: Vec<Field>,\n    // unencrypted_logs_preimages: Vec<Field>,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            read_requests: BoundedVec::new(SideEffect::empty()),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            block_header: inputs.block_header,\n\n            private_call_stack_hashes: BoundedVec::new(0),\n            public_call_stack_hashes: BoundedVec::new(0),\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.private_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.private_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_block_header(self, block_number: u32) -> BlockHeader {\n        get_block_header(block_number, self)\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let encrypted_log_preimages_length = 0;\n        let unencrypted_log_preimages_length = 0;\n\n        let priv_circuit_pub_inputs = PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            return_values: self.return_values.storage,\n            read_requests: self.read_requests.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            private_call_stack_hashes: self.private_call_stack_hashes.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            end_side_effect_counter: self.side_effect_counter,\n            encrypted_logs_hash: encrypted_logs_hash,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            encrypted_log_preimages_length: encrypted_log_preimages_length,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            block_header: self.block_header,\n            contract_deployment_data: self.inputs.contract_deployment_data,\n            chain_id: self.inputs.private_global_variables.chain_id,\n            version: self.inputs.private_global_variables.version,\n        };\n        priv_circuit_pub_inputs\n    }\n\n    pub fn push_read_request(&mut self, read_request: Field) {\n        let side_effect = SideEffect {\n            value: read_request,\n            counter: self.side_effect_counter,\n        };\n        self.read_requests.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter,\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: nullified_commitment,\n            counter: self.side_effect_counter,\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn request_nullifier_secret_key(&mut self, account: AztecAddress) -> GrumpkinScalar {\n        let key_pair = get_nullifier_key_pair(account);\n        validate_nullifier_key_against_address(account, key_pair.public_key, key_pair.secret_key);\n        // TODO: Add request to context.\n        // self.context.push_nullifier_key_validation_request(public_key, secret_key);\n        key_pair.secret_key\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, content: Field) \n    // docs:end:context_message_portal\n    {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        msg_key: Field,\n        content: Field,\n        secret: Field\n    ) \n    // docs:end:context_consume_l1_to_l2_message\n    {\n        let nullifier = process_l1_to_l2_message(self.block_header.l1_to_l2_message_tree_root, self.this_address(), self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self.inputs;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_private_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n        args: [Field; ARGS_COUNT]\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let fields = call_private_function_internal(\n            contract_address,\n            function_selector, \n            args_hash,\n            self.side_effect_counter,\n        );\n        let mut reader = Reader::new(fields);\n\n        let item = PrivateCallStackItem {\n            contract_address: AztecAddress::from_field(reader.read()),\n            function_data: FunctionData {\n                selector: FunctionSelector::from_field(reader.read()),\n                is_internal: reader.read() as bool,\n                is_private: reader.read() as bool,\n                is_constructor: reader.read() as bool,\n            },\n            public_inputs: PrivateCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : AztecAddress::from_field(reader.read()),\n                    storage_contract_address : AztecAddress::from_field(reader.read()),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                    function_selector: FunctionSelector::from_field(reader.read()), // practically same as fields[1]\n                    is_delegate_call : reader.read() as bool,\n                    is_static_call : reader.read() as bool,\n                    is_contract_deployment: reader.read() as bool,\n                    start_side_effect_counter: reader.read() as u32,\n                },\n                args_hash: reader.read(),\n                return_values: reader.read_array([0; RETURN_VALUES_LENGTH]), // +1\n                read_requests: reader.read_struct_array(SideEffect::deserialise, [SideEffect::empty(); MAX_READ_REQUESTS_PER_CALL]),\n                new_commitments: reader.read_struct_array(SideEffect::deserialise, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL]),\n                new_nullifiers: reader.read_struct_array(SideEffectLinkedToNoteHash::deserialise, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL]),\n                private_call_stack_hashes: reader.read_array([0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL]),\n                public_call_stack_hashes: reader.read_array([0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL]),\n                new_l2_to_l1_msgs: reader.read_array([0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL]),\n                end_side_effect_counter: reader.read() as u32,\n                encrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n                unencrypted_logs_hash: reader.read_array([0; NUM_FIELDS_PER_SHA256]),\n                encrypted_log_preimages_length: reader.read(),\n                unencrypted_log_preimages_length: reader.read(),\n                block_header: BlockHeader{\n                    // Must match order in `private_circuit_public_inputs.hpp`\n                    note_hash_tree_root : reader.read(),\n                    nullifier_tree_root : reader.read(),\n                    contract_tree_root : reader.read(),\n                    l1_to_l2_message_tree_root : reader.read(),\n                    archive_root : reader.read(),\n                    public_data_tree_root: reader.read(),\n                    global_variables_hash: reader.read(),\n                },\n                contract_deployment_data: ContractDeploymentData {\n                    deployer_public_key: GrumpkinPoint {\n                      x: reader.read(), \n                      y: reader.read()\n                    },\n                    constructor_vk_hash : reader.read(),\n                    function_tree_root : reader.read(),\n                    contract_address_salt : reader.read(),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                },\n                chain_id: reader.read(),\n                version: reader.read(),\n            },\n            is_execution_request: reader.read() as bool,\n        };\n\n        reader.finish();\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        self.side_effect_counter = item.public_inputs.end_side_effect_counter + 1;\n        \n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert(args_hash == item.public_inputs.args_hash);\n\n        assert(item.is_execution_request == false);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.private_call_stack_hashes.push(item.hash());\n\n        item.public_inputs.return_values\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector, \n        args: [Field; ARGS_COUNT]\n    ) {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field\n    ) {\n        let fields = enqueue_public_function_call_internal(\n            contract_address, \n            function_selector, \n            args_hash,\n            self.side_effect_counter\n        );\n\n        let mut reader = Reader::new(fields);\n\n        let item = PublicCallStackItem {\n            contract_address:  AztecAddress::from_field(reader.read()),\n            function_data: FunctionData {\n                selector: FunctionSelector::from_field(reader.read()),\n                is_internal: reader.read() as bool,\n                is_private: reader.read() as bool,\n                is_constructor: reader.read() as bool,\n            },\n            public_inputs: PublicCircuitPublicInputs {\n                call_context: CallContext {\n                    msg_sender : AztecAddress::from_field(reader.read()),\n                    storage_contract_address : AztecAddress::from_field(reader.read()),\n                    portal_contract_address : EthAddress::from_field(reader.read()),\n                    function_selector: FunctionSelector::from_field(reader.read()), // practically same as fields[1]\n                    is_delegate_call : reader.read() as bool,\n                    is_static_call : reader.read() as bool,\n                    is_contract_deployment: reader.read() as bool,\n                    start_side_effect_counter: reader.read() as u32,\n                },\n                args_hash: reader.read(),\n                return_values: [0; RETURN_VALUES_LENGTH],\n                contract_storage_update_requests: [StorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n                contract_storage_reads: [StorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n                public_call_stack_hashes: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n                new_commitments: [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL],\n                new_nullifiers: [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL],\n                new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n                unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n                unencrypted_log_preimages_length: 0,\n                block_header: BlockHeader::empty(),\n                prover_address: AztecAddress::zero(),\n            },\n            is_execution_request: true,\n        };\n        reader.finish();\n\n        assert(contract_address.eq(item.contract_address));\n        assert(function_selector.eq(item.function_data.selector));\n\n        assert_eq(item.public_inputs.call_context.start_side_effect_counter, self.side_effect_counter);\n        // We increment the sideffect counter by one, to account for the call itself being a side effect.\n        self.side_effect_counter = self.side_effect_counter + 1;\n        \n        assert(args_hash == item.public_inputs.args_hash);\n\n        // Assert that the call context of the enqueued call generated by the oracle matches our request.\n        // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n        // the msg_sender in the nested call to be equal to our address, and the execution context address\n        // for the nested call to be equal to the address we actually called.\n        assert(item.public_inputs.call_context.is_delegate_call == false);\n        assert(item.public_inputs.call_context.is_static_call == false);\n        assert(item.public_inputs.call_context.is_contract_deployment == false);\n        assert(item.public_inputs.call_context.msg_sender.eq(self.inputs.call_context.storage_contract_address));\n        assert(item.public_inputs.call_context.storage_contract_address.eq(contract_address));\n\n        self.public_call_stack_hashes.push(item.hash());\n    }\n}\n\nstruct PublicContext {\n    inputs: PublicContextInputs,\n    side_effect_counter: u32,\n\n    args_hash : Field,\n    return_values : BoundedVec<Field, RETURN_VALUES_LENGTH>,\n\n    contract_storage_update_requests: BoundedVec<StorageUpdateRequest, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>,\n    contract_storage_reads: BoundedVec<StorageRead, MAX_PUBLIC_DATA_READS_PER_CALL>,\n    public_call_stack_hashes: BoundedVec<Field, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>,\n\n    new_commitments: BoundedVec<SideEffect, MAX_NEW_COMMITMENTS_PER_CALL>,\n    new_nullifiers: BoundedVec<SideEffectLinkedToNoteHash, MAX_NEW_NULLIFIERS_PER_CALL>,\n\n    new_l2_to_l1_msgs: BoundedVec<Field, MAX_NEW_L2_TO_L1_MSGS_PER_CALL>,\n\n    unencrypted_logs_hash: BoundedVec<Field, NUM_FIELDS_PER_SHA256>,\n    unencrypted_logs_preimages_length: Field,\n\n    block_header: BlockHeader,\n    prover_address: AztecAddress,\n}\n\nimpl PublicContext {\n    pub fn new(inputs: PublicContextInputs, args_hash: Field) -> PublicContext {\n        let empty_storage_read = StorageRead::empty();\n        let empty_storage_update = StorageUpdateRequest::empty();\n        PublicContext {\n            inputs: inputs,\n            side_effect_counter: inputs.call_context.start_side_effect_counter,\n\n            args_hash: args_hash,\n            return_values: BoundedVec::new(0),\n\n            contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n            contract_storage_reads: BoundedVec::new(empty_storage_read),\n            public_call_stack_hashes: BoundedVec::new(0),\n\n            new_commitments: BoundedVec::new(SideEffect::empty()),\n            new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n            new_l2_to_l1_msgs: BoundedVec::new(0),\n\n            \n            unencrypted_logs_hash: BoundedVec::new(0),\n            unencrypted_logs_preimages_length: 0,\n\n            block_header: inputs.block_header,\n            prover_address: AztecAddress::zero(),\n\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n            // encrypted_logs_preimages: Vec::new(),\n            // unencrypted_logs_preimages: Vec::new(),\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.storage_contract_address\n    }\n\n    pub fn this_portal_address(self) -> EthAddress {\n        self.inputs.call_context.portal_contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.public_global_variables.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.public_global_variables.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn block_number(self) -> Field {\n        self.inputs.public_global_variables.block_number\n    }\n\n    pub fn timestamp(self) -> Field {\n        self.inputs.public_global_variables.timestamp\n    }\n\n    pub fn finish(self) -> PublicCircuitPublicInputs {\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n        let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n        let unencrypted_log_preimages_length = 0;\n\n\n        // Compute the public call stack hashes\n        let pub_circuit_pub_inputs = PublicCircuitPublicInputs {\n            call_context: self.inputs.call_context, // Done\n            args_hash: self.args_hash, // Done\n            contract_storage_update_requests: self.contract_storage_update_requests.storage,\n            contract_storage_reads: self.contract_storage_reads.storage,\n            return_values: self.return_values.storage,\n            new_commitments: self.new_commitments.storage,\n            new_nullifiers: self.new_nullifiers.storage,\n            public_call_stack_hashes: self.public_call_stack_hashes.storage,\n            new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n            unencrypted_logs_hash: unencrypted_logs_hash,\n            unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n            block_header: self.inputs.block_header,\n            prover_address: self.prover_address,\n        };\n        pub_circuit_pub_inputs\n    }\n\n    pub fn push_new_note_hash(&mut self, note_hash: Field) {\n        let side_effect = SideEffect {\n            value: note_hash,\n            counter: self.side_effect_counter\n        };\n        self.new_commitments.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n        let side_effect = SideEffectLinkedToNoteHash {\n            value: nullifier,\n            note_hash: 0, // cannot nullify pending notes in public context\n            counter: self.side_effect_counter\n        };\n        self.new_nullifiers.push(side_effect);\n        self.side_effect_counter = self.side_effect_counter + 1;\n    }\n\n    pub fn message_portal(&mut self, content: Field) {\n        self.new_l2_to_l1_msgs.push(content);\n    }\n\n    // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n    // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n    pub fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n        let this = (*self).this_address();\n        let nullifier = process_l1_to_l2_message(self.block_header.l1_to_l2_message_tree_root, this, self.this_portal_address(), self.chain_id(), self.version(), msg_key, content, secret);\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_new_nullifier(nullifier, 0)\n    }\n\n    pub fn accumulate_encrypted_logs<N>(&mut self, log: [Field; N]) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn accumulate_unencrypted_logs<T>(&mut self, log: T) {\n        let _void1 = self;\n        let _void2 = log;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n    }\n\n    pub fn call_public_function<ARGS_COUNT>(\n        _self: Self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        let args_hash = hash_args(args);\n        assert(args_hash == arguments::pack_arguments(args));\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            args_hash,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        _self: Self,\n        contract_address: AztecAddress, \n        function_selector: FunctionSelector,\n    ) -> [Field; RETURN_VALUES_LENGTH] {\n        call_public_function_internal(\n            contract_address, \n            function_selector, \n            0,\n        )\n    }\n\n}\n\nstruct Context {\n    private: Option<&mut PrivateContext>,\n    public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n    pub fn private(context: &mut PrivateContext) -> Context {\n        Context {\n            private: Option::some(context),\n            public: Option::none()\n        }\n    }\n\n    pub fn public(context: &mut PublicContext) -> Context {\n        Context {\n            public: Option::some(context),\n            private: Option::none()\n        }\n    }\n\n    pub fn none() -> Context {\n        Context {\n            public: Option::none(),\n            private: Option::none()\n        }\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/context.nr"
+    },
+    "43": {
+      "source": "use dep::protocol_types::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_circuit_public_inputs::PublicCircuitPublicInputs,\n    },\n    contrakt::deployment_data::ContractDeploymentData,\n    hash::hash_args,\n};\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n    chain_id: Field,\n    version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n    fn serialize(self) -> [Field; 2] {\n        [self.chain_id, self.version]\n    }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n    chain_id: Field,\n    version: Field,\n    block_number: Field,\n    timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n    fn serialize(self) -> [Field; 4] {\n        [self.chain_id, self.version, self.block_number, self.timestamp]\n    }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n    call_context : CallContext,\n    block_header: BlockHeader,\n    contract_deployment_data: ContractDeploymentData,\n    private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n    call_context: CallContext,\n    block_header: BlockHeader,\n\n    public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\nstruct Hasher {\n    fields: [Field],\n}\n\nimpl Hasher {\n    pub fn new()-> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<N>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n\n    pub fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/abi.nr"
+    },
+    "47": {
+      "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse dep::protocol_types::{\n    constants::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL},\n    abis::side_effect::{SideEffect, SideEffectLinkedToNoteHash},\n};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n    lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n    note_getter::{get_notes, view_notes},\n    note_getter_options::NoteGetterOptions,\n    note_header::NoteHeader,\n    note_interface::NoteInterface,\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_or_nullify,\n};\n\n// docs:start:struct\nstruct Set<Note, N> {\n    context: Context,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n}\n// docs:end:struct\n\nimpl<Note, N> Set<Note, N> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        note_interface: NoteInterface<Note, N>,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Set {\n            context,\n            storage_slot,\n            note_interface,\n        }\n    }\n    // docs:end:new\n\n    // docs:start:insert\n    pub fn insert(self,\n        note: &mut Note,\n        broadcast: bool,\n    ) {\n        create_note(\n            self.context.private.unwrap(),\n            self.storage_slot,\n            note,\n            self.note_interface,\n            broadcast,\n        );\n    }\n    // docs:end:insert\n\n    // docs:start:insert_from_public\n    pub fn insert_from_public(self, note: &mut Note) {\n        create_note_hash_from_public(\n            self.context.public.unwrap(),\n            self.storage_slot,\n            note,\n            self.note_interface,\n        );\n    }\n    // docs:end:insert_from_public\n    \n    // DEPRECATED\n    fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) {\n        assert(false, \"`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n    }\n\n    // DEPRECATED\n    fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) {\n        assert(false, \"`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n    }\n\n    // docs:start:remove\n    pub fn remove(self, note: Note) {\n        let context = self.context.private.unwrap();\n        let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n        let has_been_read = context.read_requests.any(|r: SideEffect| r.value == note_hash);\n        assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n        destroy_note(\n            context,\n            note,\n            self.note_interface,\n        );\n    }\n    // docs:end:remove\n\n    // docs:start:get_notes\n    pub fn get_notes<FILTER_ARGS>(\n        self,\n        options: NoteGetterOptions<Note, N, FILTER_ARGS>,\n    ) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL] {\n        let storage_slot = self.storage_slot;\n        let opt_notes = get_notes(\n            self.context.private.unwrap(),\n            storage_slot,\n            self.note_interface,\n            options,\n        );\n        opt_notes\n    }\n    // docs:end:get_notes\n\n    // docs:start:view_notes\n    unconstrained pub fn view_notes(\n        self,\n        options: NoteViewerOptions<Note, N>,\n    ) -> [Option<Note>; MAX_NOTES_PER_PAGE] {\n        view_notes(self.storage_slot, self.note_interface, options)\n    }\n    // docs:end:view_notes\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/state_vars/set.nr"
+    },
+    "49": {
+      "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\nuse dep::protocol_types::{\n    hash::pedersen_hash,\n    traits::{ToField}\n};\n\n// docs:start:map\nstruct Map<K, V> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, V> Map<K, V> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map {\n            context,\n            storage_slot,\n            state_var_constructor,\n        }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V where K: ToField {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = pedersen_hash([self.storage_slot, key.to_field()],0);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/state_vars/map.nr"
+    },
+    "50": {
+      "source": "use crate::context::{Context};\nuse crate::oracle::storage::storage_read;\nuse crate::oracle::storage::storage_write;\nuse crate::types::type_serialization::TypeSerializationInterface;\nuse dep::std::option::Option;\n\n// docs:start:public_state_struct\nstruct PublicState<T, T_SERIALIZED_LEN> {\n    context: Context,\n    storage_slot: Field,\n    serialization_methods: TypeSerializationInterface<T, T_SERIALIZED_LEN>,\n}\n// docs:end:public_state_struct\n\nimpl<T, T_SERIALIZED_LEN> PublicState<T, T_SERIALIZED_LEN> {\n    // docs:start:public_state_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n        serialization_methods: TypeSerializationInterface<T, T_SERIALIZED_LEN>,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicState {\n            context,\n            storage_slot,\n            serialization_methods,\n        }\n    }\n    // docs:end:public_state_struct_new\n\n    // docs:start:public_state_struct_read\n    pub fn read(self) -> T {\n        assert(self.context.private.is_none(), \"Public state reads only supported in public functions\");\n        storage_read(self.storage_slot, self.serialization_methods.deserialize)\n    }\n    // docs:end:public_state_struct_read\n\n    // docs:start:public_state_struct_write\n    pub fn write(self, value: T) {\n        assert(self.context.private.is_none(), \"Public state writes only supported in public functions\");\n        let serialize = self.serialization_methods.serialize;\n        let fields = serialize(value);\n        storage_write(self.storage_slot, fields);\n    }\n    // docs:end:public_state_struct_write\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/state_vars/public_state.nr"
+    },
+    "56": {
+      "source": "#[oracle(storageRead)]\nfn storage_read_oracle<N>(_storage_slot: Field, _number_of_elements: Field) -> [Field; N] {}\n\nunconstrained fn storage_read_oracle_wrapper<N>(_storage_slot: Field) -> [Field; N] {\n    storage_read_oracle(_storage_slot, N)\n}\n\npub fn storage_read<T, N>(storage_slot: Field, deserialize: fn([Field; N]) -> T) -> T {\n    let fields = storage_read_oracle_wrapper(storage_slot);\n    deserialize(fields)\n}\n\n#[oracle(storageWrite)]\nfn storage_write_oracle<N>(_storage_slot: Field, _values: [Field; N]) -> [Field; N] {}\n\n// TODO: Remove return value.\nunconstrained pub fn storage_write<N>(storage_slot: Field, fields: [Field; N]) {\n    let _hash = storage_write_oracle(storage_slot, fields);\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/storage.nr"
+    },
+    "57": {
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::NUM_FIELDS_PER_SHA256,\n    grumpkin_point::GrumpkinPoint,\n};\n\n// TODO: Should take encrypted data.\n#[oracle(emitEncryptedLog)]\nfn emit_encrypted_log_oracle<N>(\n    _contract_address: AztecAddress,\n    _storage_slot: Field,\n    _encryption_pub_key: GrumpkinPoint,\n    _preimage: [Field; N]\n) -> Field {}\n\nunconstrained pub fn emit_encrypted_log<N>(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    encryption_pub_key: GrumpkinPoint,\n    preimage: [Field; N]\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n    [emit_encrypted_log_oracle(contract_address, storage_slot, encryption_pub_key, preimage), 0]\n}\n\n#[oracle(emitUnencryptedLog)]\nfn emit_unencrypted_log_oracle<T>(_contract_address: AztecAddress, _event_selector: Field, _message: T) -> Field {}\n\nunconstrained pub fn emit_unencrypted_log<T>(\n    contract_address: AztecAddress,\n    event_selector: Field,\n    message: T\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n    // https://github.com/AztecProtocol/aztec-packages/issues/885\n    [emit_unencrypted_log_oracle(contract_address, event_selector, message), 0]\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/logs.nr"
+    },
+    "59": {
+      "source": "#[oracle(packArguments)]\nfn pack_arguments_oracle<N>(_args: [Field; N]) -> Field {}\n\n// TODO: explain what this does.\nunconstrained pub fn pack_arguments<N>(args: [Field; N]) -> Field {\n    pack_arguments_oracle(args)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/arguments.nr"
+    },
+    "61": {
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::RETURN_VALUES_LENGTH,\n};\n\n#[oracle(callPublicFunction)]\nfn call_public_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field\n) -> [Field; RETURN_VALUES_LENGTH] {}\n\nunconstrained pub fn call_public_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field\n) -> [Field; RETURN_VALUES_LENGTH] {\n    call_public_function_oracle(contract_address, function_selector, args_hash)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/public_call.nr"
+    },
+    "65": {
+      "source": "use dep::protocol_types::{\n    address::{\n        AztecAddress,\n        PartialAddress,\n    },\n    grumpkin_point::GrumpkinPoint,\n};\n\n#[oracle(getPublicKeyAndPartialAddress)]\nfn get_public_key_and_partial_address_oracle(_address: AztecAddress) -> [Field; 3] {}\n\nunconstrained fn get_public_key_and_partial_address_internal(address: AztecAddress) -> [Field; 3] {\n    get_public_key_and_partial_address_oracle(address)\n}\n\npub fn get_public_key(address: AztecAddress) -> GrumpkinPoint {\n    let result = get_public_key_and_partial_address_internal(address);\n    let pub_key = GrumpkinPoint::new(result[0], result[1]);\n    let partial_address = PartialAddress::from_field(result[2]);\n\n    let calculated_address = AztecAddress::compute(pub_key, partial_address);\n    assert(calculated_address.eq(address));\n\n    pub_key\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/get_public_key.nr"
+    },
+    "69": {
+      "source": "#[oracle(getRandomField)]\nfn rand_oracle() -> Field {}\n\nunconstrained pub fn rand() -> Field {\n    rand_oracle()\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/rand.nr"
+    },
+    "70": {
+      "source": "use dep::std::option::Option;\nuse crate::note::{\n    note_header::NoteHeader,\n    note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\nuse dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyCreatedNote)]\nfn notify_created_note_oracle<N>(_storage_slot: Field, _serialized_note: [Field; N], _inner_note_hash: Field) -> Field {}\n\nunconstrained pub fn notify_created_note<N>(storage_slot: Field, serialized_note: [Field; N], inner_note_hash: Field) -> Field {\n    notify_created_note_oracle(storage_slot, serialized_note, inner_note_hash)\n}\n\n#[oracle(notifyNullifiedNote)]\nfn notify_nullified_note_oracle<N>(_nullifier: Field, _inner_note_hash: Field) -> Field {}\n\nunconstrained pub fn notify_nullified_note<N>(nullifier: Field, inner_note_hash: Field) -> Field {\n    notify_nullified_note_oracle(nullifier, inner_note_hash)\n}\n\n#[oracle(getNotes)]\nfn get_notes_oracle<N, S>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by: [u8; N],\n    _select_values: [Field; N],\n    _sort_by: [u8; N],\n    _sort_order: [u2; N],\n    _limit: u32,\n    _offset: u32,\n    _return_size: u32,\n    _placeholder_fields: [Field; S]\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<N, S>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by: [u8; N],\n    select_values: [Field; N],\n    sort_by: [u8; N],\n    sort_order: [u2; N],\n    limit: u32,\n    offset: u32,\n    mut placeholder_fields: [Field; S]\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        limit,\n        offset,\n        return_size,\n        placeholder_fields\n    )\n}\n\nunconstrained pub fn get_notes<Note, N, M, S, NS>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    num_selects: u8,\n    select_by: [u8; M],\n    select_values: [Field; M],\n    sort_by: [u8; M],\n    sort_order: [u2; M],\n    limit: u32,\n    offset: u32,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS] // TODO: Remove it and use `limit` to initialize the note array.\n) -> [Option<Note>; S] {\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        limit,\n        offset,\n        placeholder_fields\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    let deserialize = note_interface.deserialize;\n    let set_header = note_interface.set_header;\n    for i in 0..placeholder_opt_notes.len() {\n        if i as u32 < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: Field = 2; // num_notes & contract_address.\n            let extra_preimage_length: Field = 2; // nonce & is_transient.\n            let read_offset: Field = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let is_transient = fields[read_offset + 1] as bool;\n            let header = NoteHeader { contract_address, nonce, storage_slot, is_transient };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = deserialize(serialized_note);\n            set_header(&mut note, header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n#[oracle(checkNullifierExists)]\nfn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\nunconstrained pub fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/notes.nr"
+    },
+    "73": {
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::grumpkin_scalar::GrumpkinScalar;\n\nstruct KeyPair {\n    public_key: GrumpkinPoint,\n    secret_key: GrumpkinScalar,\n}\n\n#[oracle(getNullifierKeyPair)]\nfn get_nullifier_key_pair_oracle(_account: AztecAddress) -> [Field; 4] {}\n\nunconstrained fn get_nullifier_key_pair_internal(account: AztecAddress) -> KeyPair {\n    let result = get_nullifier_key_pair_oracle(account);\n    KeyPair {\n        public_key: GrumpkinPoint { x: result[0], y: result[1] },\n        secret_key: GrumpkinScalar { high: result[2], low: result[3] }\n    }\n}\n\npub fn get_nullifier_key_pair(account: AztecAddress) -> KeyPair {\n    get_nullifier_key_pair_internal(account)\n}\n\npub fn get_nullifier_secret_key(account: AztecAddress) -> GrumpkinScalar {\n    get_nullifier_key_pair_internal(account).secret_key\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/oracle/nullifier_key.nr"
+    },
+    "76": {
+      "source": "pub fn arr_copy_slice<T, N, M>(src: [T; N], mut dst: [T; M], offset: Field) -> [T; M] {\n    for i in 0..dst.len() {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n\n// TODO(#3470): Copied over from https://github.com/AztecProtocol/aztec-packages/blob/a07c4bd47313be6aa604a63f37857eb0136b41ba/yarn-project/noir-protocol-circuits/src/crates/rollup-lib/src/base/base_rollup_inputs.nr#L599\n// move to a shared place?\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\nstruct Reader<N> {\n    data: [Field; N],\n    offset: Field,\n}\n\nimpl<N> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_array<K>(&mut self, mut result: [Field; K]) -> [Field; K] {\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, K>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array([0; K]));\n        result\n    }\n\n    pub fn read_struct_array<T, K, C>(&mut self, deserialise: fn([Field; K]) -> T, mut result: [T; C]) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    } \n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/utils.nr"
+    },
+    "77": {
+      "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::oracle;\nuse dep::protocol_types::{\n    address::AztecAddress,\n    grumpkin_point::GrumpkinPoint,\n};\n\npub fn emit_encrypted_log<N>(\n    context: &mut PrivateContext,\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    encryption_pub_key: GrumpkinPoint,\n    log: [Field; N]\n) {\n    let _ = oracle::logs::emit_encrypted_log(contract_address, storage_slot, encryption_pub_key, log);\n    context.accumulate_encrypted_logs(log);\n}\n\npub fn emit_unencrypted_log<T>(context: &mut PublicContext, log: T) {\n    let contract_address = context.this_address();\n    let event_selector = 5; // TODO: compute actual event selector.\n    let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n    // context.accumulate_unencrypted_logs(log);\n}\n\n// TODO: We might want to remove this since emitting unencrypted logs from private functions is violating privacy.\n// --> might be a better approach to force devs to make a public function call that emits the log if needed then\n// it would be less easy to accidentally leak information.\n// If we decide to keep this function around would make sense to wait for traits and then merge it with emit_unencrypted_log.\npub fn emit_unencrypted_log_from_private<T>(context: &mut PrivateContext, log: T) {\n    let contract_address = context.this_address();\n    let event_selector = 5; // TODO: compute actual event selector.\n    let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n    // context.accumulate_unencrypted_logs(log);\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/log.nr"
+    },
+    "78": {
+      "source": "use crate::oracle::get_public_key::get_public_key;\nuse dep::protocol_types::{\n    address::AztecAddress,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::{\n    grumpkin_scalar::GrumpkinScalar,\n    grumpkin_scalar_mul::grumpkin_fixed_base,\n};\n\npub fn validate_nullifier_key_against_address(\n    address: AztecAddress,\n    nullifier_public_key: GrumpkinPoint,\n    nullifier_secret_key: GrumpkinScalar\n) {\n    // TODO: Nullifier public key should be part of the address.\n    // Validation of the secret key should happen in the kernel circuit.\n    let owner_public_key = get_public_key(address);\n    assert(owner_public_key.x == nullifier_public_key.x);\n    assert(owner_public_key.y == nullifier_public_key.y);\n    let computed_public_key = grumpkin_fixed_base(nullifier_secret_key);\n    assert(owner_public_key.x == computed_public_key[0]);\n    assert(owner_public_key.y == computed_public_key[1]);\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/key/nullifier_key.nr"
+    },
+    "87": {
+      "source": "use dep::std::option::Option;\nuse dep::protocol_types::constants::{\n    MAX_READ_REQUESTS_PER_CALL,\n    GET_NOTE_ORACLE_RETURN_LENGTH,\n    GET_NOTES_ORACLE_RETURN_LENGTH,\n    MAX_NOTES_PER_PAGE,\n    VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n    note_getter_options::{NoteGetterOptions, Select, Sort, SortOrder},\n    note_interface::NoteInterface,\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_or_nullify,\n};\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header<Note, N>(\n    context: PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    note: Note\n) {\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n    let contract_address = context.this_address();\n    assert(header.contract_address.eq(contract_address));\n    assert(header.storage_slot == storage_slot);\n}\n\nfn check_note_fields<N>(fields: [Field; N], selects: BoundedVec<Option<Select>, N>) {\n    for i in 0..selects.len {\n        let select = selects.get_unchecked(i).unwrap_unchecked();\n        assert(fields[select.field_index] == select.value, \"Mismatch return note field.\");\n    }\n}\n\nfn check_notes_order<N>(\n    fields_0: [Field; N],\n    fields_1: [Field; N],\n    sorts: BoundedVec<Option<Sort>, N>\n) {\n    for i in 0..sorts.len {\n        let sort = sorts.get_unchecked(i).unwrap_unchecked();\n        let eq = fields_0[sort.field_index] == fields_1[sort.field_index];\n        let lt = fields_0[sort.field_index] as u120 < fields_1[sort.field_index] as u120;\n        if sort.order == SortOrder.ASC {\n            assert(eq | lt, \"Return notes not sorted in ascending order.\");\n        } else if !eq {\n            assert(!lt, \"Return notes not sorted in descending order.\");\n        }\n    }\n}\n\npub fn get_note<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>\n) -> Note {\n    let note = get_note_internal(storage_slot, note_interface);\n\n    check_note_header(*context, storage_slot, note_interface, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n    context.push_read_request(note_hash_for_read_request);\n    note\n}\n\npub fn get_notes<Note, N, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteGetterOptions<Note, N, FILTER_ARGS>\n) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL] {\n    let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n    let mut num_notes = 0;\n    let mut prev_fields = [0; N];\n    for i in 0..opt_notes.len() {\n        let opt_note = opt_notes[i];\n        if opt_note.is_some() {\n            let note = opt_note.unwrap_unchecked();\n            let serialize = note_interface.serialize;\n            let fields = serialize(note);\n            check_note_header(*context, storage_slot, note_interface, note);\n            check_note_fields(fields, options.selects);\n            if i != 0 {\n                check_notes_order(prev_fields, fields, options.sorts);\n            }\n            prev_fields = fields;\n\n            let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n            // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n            context.push_read_request(note_hash_for_read_request);\n\n            num_notes += 1;\n        };\n    }\n    if options.limit != 0 {\n        assert(num_notes <= options.limit, \"Invalid number of return notes.\");\n    }\n    opt_notes\n}\n\nunconstrained fn get_note_internal<Note, N>(storage_slot: Field, note_interface: NoteInterface<Note, N>) -> Note {\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        0,\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        placeholder_note,\n        placeholder_fields\n    )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, N, FILTER_ARGS>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteGetterOptions<Note, N, FILTER_ARGS>\n) -> [Option<Note>; MAX_READ_REQUESTS_PER_CALL] {\n    let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    let opt_notes = oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        options.limit,\n        options.offset,\n        placeholder_opt_notes,\n        placeholder_fields\n    );\n\n    let filter = options.filter;\n    let filter_args = options.filter_args;\n    filter(opt_notes, filter_args)\n}\n\nunconstrained pub fn view_notes<Note, N>(\n    storage_slot: Field,\n    note_interface: NoteInterface<Note, N>,\n    options: NoteViewerOptions<Note, N>\n) -> [Option<Note>; MAX_NOTES_PER_PAGE] {\n    let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    oracle::notes::get_notes(\n        storage_slot,\n        note_interface,\n        num_selects,\n        select_by,\n        select_values,\n        sort_by,\n        sort_order,\n        options.limit,\n        options.offset,\n        placeholder_opt_notes,\n        placeholder_fields\n    )\n}\n\nunconstrained fn flatten_options<Note, N>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n    let mut num_selects = 0;\n    let mut select_by = [0; N];\n    let mut select_values = [0; N];\n    for i in 0..selects.len {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by[num_selects] = select.unwrap_unchecked().field_index;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            num_selects += 1;\n        };\n    }\n\n    let mut sort_by = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by[i] = sort.unwrap_unchecked().field_index;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    }\n\n    (num_selects, select_by, select_values, sort_by, sort_order)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/note/note_getter.nr"
+    },
+    "88": {
+      "source": "use crate::abi::PublicContextInputs;\nuse crate::context::{\n    PrivateContext,\n    PublicContext,\n};\nuse crate::note::{\n    note_header::NoteHeader,\n    note_interface::NoteInterface,\n    utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note<Note, N>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n    note_interface: NoteInterface<Note, N>,\n    broadcast: bool\n) {\n    let contract_address = (*context).this_address();\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n    let set_header = note_interface.set_header;\n    set_header(note, header);\n    let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n    let serialize = note_interface.serialize;\n    let serialized_note = serialize(*note);\n    assert(notify_created_note(storage_slot, serialized_note, inner_note_hash) == 0);\n\n    context.push_new_note_hash(inner_note_hash);\n\n    if broadcast {\n        let broadcast = note_interface.broadcast;\n        broadcast(context, storage_slot, *note);\n    }\n}\n\npub fn create_note_hash_from_public<Note, N>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n    note_interface: NoteInterface<Note, N>\n) {\n    let contract_address = (*context).this_address();\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n    let set_header = note_interface.set_header;\n    set_header(note, header);\n    let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n    context.push_new_note_hash(inner_note_hash);\n}\n\npub fn destroy_note<Note, N>(\n    context: &mut PrivateContext,\n    note: Note,\n    note_interface: NoteInterface<Note, N>\n) {\n    let mut nullifier = 0;\n    let mut nullified_commitment: Field = 0;\n    let compute_nullifier = note_interface.compute_nullifier;\n    nullifier = compute_nullifier(note, context);\n\n    // We also need the note commitment corresponding to the \"nullifier\"\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n    // `nullified_commitment` is used to inform the kernel which pending commitment\n    // the nullifier corresponds to so they can be matched and both squashed/deleted.\n    // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n    // commitment) in which case `nullified_commitment` is not used since the kernel\n    // just siloes and forwards the nullifier to its output.\n    if (header.is_transient) {\n        // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`?\n        nullified_commitment = compute_inner_note_hash(note_interface, note);\n    }\n    assert(notify_nullified_note(nullifier, nullified_commitment) == 0);\n\n    context.push_new_nullifier(nullifier, nullified_commitment)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/note/lifecycle.nr"
+    },
+    "91": {
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{\n        GENERATOR_INDEX__UNIQUE_COMMITMENT,\n        GENERATOR_INDEX__SILOED_COMMITMENT,\n    },\n    hash::pedersen_hash,\n};\n\npub fn compute_inner_hash(storage_slot: Field, note_hash: Field) -> Field {\n    // TODO(#1205) Do we need a generator index here?\n    pedersen_hash([storage_slot, note_hash], 0)\n}\n\npub fn compute_siloed_hash(contract_address: AztecAddress, inner_note_hash: Field) -> Field {\n    let inputs = [contract_address.to_field(), inner_note_hash];\n    pedersen_hash(inputs, GENERATOR_INDEX__SILOED_COMMITMENT)\n}\n\npub fn compute_unique_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    pedersen_hash(inputs, GENERATOR_INDEX__UNIQUE_COMMITMENT)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/note/note_hash.nr"
+    },
+    "92": {
+      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__OUTER_NULLIFIER,\n    hash::pedersen_hash,\n};\nuse crate::{\n    context::PrivateContext,\n    note::{\n        note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n        note_header::NoteHeader,\n        note_interface::NoteInterface,\n    },\n    utils::arr_copy_slice,\n};\n\npub fn compute_inner_note_hash<Note, N>(note_interface: NoteInterface<Note, N>, note: Note) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note);\n\n    let compute_note_hash = note_interface.compute_note_hash;\n    let note_hash = compute_note_hash(note);\n\n    compute_inner_hash(header.storage_slot, note_hash)\n}\n\npub fn compute_siloed_note_hash<Note, N>(note_interface: NoteInterface<Note, N>, note_with_header: Note) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n    compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\npub fn compute_unique_siloed_note_hash<Note, N>(note_interface: NoteInterface<Note, N>, note_with_header: Note) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n    compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier<Note, N>(\n    note_interface: NoteInterface<Note, N>,\n    note_with_header: Note,\n    context: &mut PrivateContext\n) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    let compute_nullifier = note_interface.compute_nullifier;\n    let inner_nullifier = compute_nullifier(note_with_header, context);\n\n    let input = [header.contract_address.to_field(), inner_nullifier];\n    pedersen_hash(input, GENERATOR_INDEX__OUTER_NULLIFIER)\n}\n\npub fn compute_note_hash_for_read_or_nullify<Note, N>(note_interface: NoteInterface<Note, N>, note_with_header: Note) -> Field {\n    let get_header = note_interface.get_header;\n    let header = get_header(note_with_header);\n\n    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n    if (header.is_transient) {\n        // If a note is transient, we just read the inner_note_hash (kernel will silo by contract address).\n        compute_inner_note_hash(note_interface, note_with_header)\n    } else if (header.nonce == 0) {\n        // If not transient and nonce is zero, that means we are reading a public note.\n        compute_siloed_note_hash(note_interface, note_with_header)\n    } else {\n        // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n        // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n        // contract address and then nonce. This hash will match the existing leaf in the private\n        // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n        compute_unique_siloed_note_hash(note_interface, note_with_header)\n    }\n}\n\npub fn compute_note_hash_and_nullifier<Note, N, S>(\n    note_interface: NoteInterface<Note, N>,\n    note_header: NoteHeader,\n    serialized_note: [Field; S]\n) -> [Field; 4] {\n    let deserialize = note_interface.deserialize;\n    let set_header = note_interface.set_header;\n    let mut note = deserialize(arr_copy_slice(serialized_note, [0; N], 0));\n    set_header(&mut note, note_header);\n\n    let compute_note_hash = note_interface.compute_note_hash;\n    let note_hash = compute_note_hash(note);\n    let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n    let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n    let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n    let compute_nullifier_without_context = note_interface.compute_nullifier_without_context;\n    let inner_nullifier = compute_nullifier_without_context(note);\n\n    [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/note/utils.nr"
+    },
+    "94": {
+      "source": "struct BoundedVec<T, MaxLen> {\n    storage: [T; MaxLen],\n    len: Field,\n}\n\nimpl<T, MaxLen> BoundedVec<T, MaxLen> {\n    pub fn new(initial_value: T) -> Self {\n        BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n    }\n\n    pub fn get(mut self: Self, index: Field) -> T {\n        assert(index as u64 < self.len as u64);\n        self.storage[index]\n    }\n\n    pub fn get_unchecked(mut self: Self, index: Field) -> T {\n        self.storage[index]\n    }\n\n    pub fn push(&mut self, elem: T) {\n        assert(self.len as u64 < MaxLen as u64);\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    pub fn push_array<Len>(&mut self, array: [T; Len]) {\n        let newLen = self.len + array.len();\n        assert(newLen as u64 <= MaxLen as u64);\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = newLen;\n    }\n\n    pub fn pop(&mut self) -> T {\n        assert(self.len as u64 > 0);\n\n        let elem = self.storage[self.len - 1];\n        self.len -= 1;\n        elem\n    }\n\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if (!exceeded_len) {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n}\n\n#[test]\nfn test_vec_push_pop() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    assert(vec.len == 0);\n    vec.push(2);\n    assert(vec.len == 1);\n    vec.push(4);\n    assert(vec.len == 2);\n    vec.push(6);\n    assert(vec.len == 3);\n    let x = vec.pop();\n    assert(x == 6);\n    assert(vec.len == 2);\n    assert(vec.get(0) == 2);\n    assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    vec.push_array([2, 4]);\n    assert(vec.len == 2);\n    assert(vec.get(0) == 2);\n    assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    vec.push_array([2, 4]);\n    let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    vec.push_array([2]);\n    let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialized() {\n    let mut vec: BoundedVec<Field, 2> = BoundedVec::new(0);\n    let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n    let mut vec: BoundedVec<Field, 1> = BoundedVec::new(0);\n    vec.push(1);\n    vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(0);\n    vec.push_array([2, 4, 6]);\n    assert(vec.any(|v| v == 2) == true);\n    assert(vec.any(|v| v == 4) == true);\n    assert(vec.any(|v| v == 6) == true);\n    assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n    let default_value = 1;\n    let mut vec: BoundedVec<Field, 3> = BoundedVec::new(default_value);\n    vec.push_array([2, 4]);\n    assert(vec.any(|v| v == default_value) == false);\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/types/vec.nr"
+    },
+    "97": {
+      "source": "use crate::types::type_serialization::TypeSerializationInterface;\n\n// docs:start:field_serialization\nglobal FIELD_SERIALIZED_LEN: Field = 1;\n\nfn deserializeField(fields: [Field; FIELD_SERIALIZED_LEN]) -> Field {\n    fields[0]\n}\n\nfn serializeField(value: Field) -> [Field; FIELD_SERIALIZED_LEN] {\n    [value]\n}\n\nglobal FieldSerializationMethods = TypeSerializationInterface {\n    deserialize: deserializeField,\n    serialize: serializeField,\n};\n// docs:end:field_serialization",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/aztec/src/types/type_serialization/field_serialization.nr"
+    },
+    "105": {
+      "source": "global ARGS_LENGTH: Field = 16;\nglobal RETURN_VALUES_LENGTH: Field = 4;\n\n/**\n * Convention for constant array lengths are mainly divided in 2 classes:\n *  - FUNCTION CALL\n *  - TRANSACTION\n *\n * Agreed convention is to use MAX_XXX_PER_CALL resp. MAX_XXX_PER_TX, where XXX denotes a type of element such as\n * commitment, or nullifier, e.g.,:\n *  - MAX_NEW_NULLIFIERS_PER_CALL\n *  - MAX_NEW_COMMITMENTS_PER_TX\n *\n * In the kernel circuits, we accumulate elements such as commitments and the nullifiers from all functions calls in a\n * transaction. Therefore, we always must have:\n * MAX_XXX_PER_TX ≥ MAX_XXX_PER_CALL\n *\n * For instance:\n * MAX_NEW_COMMITMENTS_PER_TX ≥ MAX_NEW_COMMITMENTS_PER_CALL\n * MAX_NEW_NULLIFIERS_PER_TX ≥ MAX_NEW_NULLIFIERS_PER_CALL\n *\n */\n\n// docs:start:constants\n// \"PER CALL\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_CALL: Field = 16;\nglobal MAX_NEW_NULLIFIERS_PER_CALL: Field = 16;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL: Field = 4;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_CALL: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_CALL: Field = 16;\nglobal MAX_READ_REQUESTS_PER_CALL: Field = 32;\n\n// \"PER TRANSACTION\" CONSTANTS\nglobal MAX_NEW_COMMITMENTS_PER_TX: Field = 64;\nglobal MAX_NEW_NULLIFIERS_PER_TX: Field = 64;\nglobal MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX: Field = 8;\nglobal MAX_NEW_L2_TO_L1_MSGS_PER_TX: Field = 2;\nglobal MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX: Field = 16;\nglobal MAX_PUBLIC_DATA_READS_PER_TX: Field = 16;\nglobal MAX_NEW_CONTRACTS_PER_TX: Field = 1;\nglobal MAX_OPTIONALLY_REVEALED_DATA_LENGTH_PER_TX: Field = 4;\nglobal MAX_READ_REQUESTS_PER_TX: Field = 128;\nglobal NUM_ENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\nglobal NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: Field = 1;\n// docs:end:constants\n\n// ROLLUP CONTRACT CONSTANTS - constants used only in l1-contracts\nglobal NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP: Field = 16;\n\n// TREES RELATED CONSTANTS\nglobal VK_TREE_HEIGHT: Field = 3;\nglobal FUNCTION_TREE_HEIGHT: Field = 5;\nglobal CONTRACT_TREE_HEIGHT: Field = 16;\nglobal NOTE_HASH_TREE_HEIGHT: Field = 32;\nglobal PUBLIC_DATA_TREE_HEIGHT: Field = 40;\nglobal NULLIFIER_TREE_HEIGHT: Field = 20;\nglobal L1_TO_L2_MSG_TREE_HEIGHT: Field = 16;\nglobal ROLLUP_VK_TREE_HEIGHT: Field = 8;\n\n// SUB-TREES RELATED CONSTANTS\nglobal CONTRACT_SUBTREE_HEIGHT: Field = 0;\nglobal CONTRACT_SUBTREE_SIBLING_PATH_LENGTH: Field = 16;\nglobal NOTE_HASH_SUBTREE_HEIGHT: Field = 6;\nglobal NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH: Field = 26;\nglobal NULLIFIER_SUBTREE_HEIGHT: Field = 6;\nglobal PUBLIC_DATA_SUBTREE_HEIGHT: Field = 4;\nglobal ARCHIVE_HEIGHT: Field = 16;\nglobal NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH: Field = 14;\nglobal PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH: Field = 36;\nglobal L1_TO_L2_MSG_SUBTREE_HEIGHT: Field = 4;\nglobal L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH: Field = 12;\n\n// MISC CONSTANTS\nglobal FUNCTION_SELECTOR_NUM_BYTES: Field = 4;\nglobal MAPPING_SLOT_PEDERSEN_SEPARATOR: Field = 4;\n// sha256 hash is stored in two fields to accommodate all 256-bits of the hash\nglobal NUM_FIELDS_PER_SHA256: Field = 2;\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\n// NOIR CONSTANTS - constants used only in yarn-packages/noir-contracts\n// Some are defined here because Noir doesn't yet support globals referencing other globals yet.\n// Move these constants to a noir file once the issue bellow is resolved:\n// https://github.com/noir-lang/noir/issues/1734\nglobal L1_TO_L2_MESSAGE_LENGTH: Field = 8;\nglobal L1_TO_L2_MESSAGE_ORACLE_CALL_LENGTH: Field = 25;\nglobal MAX_NOTE_FIELDS_LENGTH: Field = 20;\n// GET_NOTE_ORACLE_RETURN_LENGT = MAX_NOTE_FIELDS_LENGTH + 1 + 2\n// The plus 1 is 1 extra field for nonce.\n// + 2 for EXTRA_DATA: [number_of_return_notes, contract_address]\nglobal GET_NOTE_ORACLE_RETURN_LENGTH: Field = 23;\nglobal MAX_NOTES_PER_PAGE: Field = 10;\n// VIEW_NOTE_ORACLE_RETURN_LENGTH = MAX_NOTES_PER_PAGE * (MAX_NOTE_FIELDS_LENGTH + 1) + 2;\nglobal VIEW_NOTE_ORACLE_RETURN_LENGTH: Field = 212;\nglobal CALL_CONTEXT_LENGTH: Field = 8;\nglobal BLOCK_HEADER_LENGTH: Field = 7;\nglobal FUNCTION_DATA_LENGTH: Field = 4;\nglobal CONTRACT_DEPLOYMENT_DATA_LENGTH: Field = 6;\n// Change this ONLY if you have changed the PrivateCircuitPublicInputs structure.\n// In other words, if the structure/size of the public inputs of a function call changes then we\n// should change this constant as well as the offsets in private_call_stack_item.nr\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 189;\nglobal CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 3;\nglobal CONTRACT_STORAGE_READ_LENGTH: Field = 2;\n// Change this ONLY if you have changed the PublicCircuitPublicInputs structure.\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 190;\nglobal GET_NOTES_ORACLE_RETURN_LENGTH: Field = 674;\nglobal CALL_PRIVATE_FUNCTION_RETURN_SIZE: Field = 195;\nglobal PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 87;\nglobal PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 177;\nglobal COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048;\nglobal PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP: Field = 1024;\nglobal CONTRACTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 32;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP_UNPADDED: Field = 52;\nglobal L2_TO_L1_MSGS_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\nglobal LOGS_HASHES_NUM_BYTES_PER_BASE_ROLLUP: Field = 64;\n\n/**\n * Enumerate the hash_indices which are used for pedersen hashing.\n * We start from 1 to avoid the default generators. The generator indices are listed\n * based on the number of elements each index hashes. The following conditions must be met:\n *\n * +-----------+-------------------------------+----------------------+\n * | Hash size | Number of elements hashed (n) | Condition to use     |\n * |-----------+-------------------------------+----------------------|\n * | LOW       | n ≤ 8                         | 0 < hash_index ≤ 32  |\n * | MID       | 8 < n ≤ 16                    | 32 < hash_index ≤ 40 |\n * | HIGH      | 16 < n ≤ 48                   | 40 < hash_index ≤ 48 |\n * +-----------+-------------------------------+----------------------+\n *\n * Note: When modifying, modify `GeneratorIndexPacker` in packer.hpp accordingly.\n */\n// Indices with size ≤ 8\nglobal GENERATOR_INDEX__COMMITMENT = 1;\nglobal GENERATOR_INDEX__COMMITMENT_NONCE = 2;\nglobal GENERATOR_INDEX__UNIQUE_COMMITMENT = 3;\nglobal GENERATOR_INDEX__SILOED_COMMITMENT = 4;\nglobal GENERATOR_INDEX__NULLIFIER = 5;\nglobal GENERATOR_INDEX__INITIALIZATION_NULLIFIER = 6;\nglobal GENERATOR_INDEX__OUTER_NULLIFIER = 7;\nglobal GENERATOR_INDEX__PUBLIC_DATA_READ = 8;\nglobal GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST = 9;\nglobal GENERATOR_INDEX__FUNCTION_DATA = 10;\nglobal GENERATOR_INDEX__FUNCTION_LEAF = 11;\nglobal GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA = 12;\nglobal GENERATOR_INDEX__CONSTRUCTOR = 13;\nglobal GENERATOR_INDEX__CONSTRUCTOR_ARGS = 14;\nglobal GENERATOR_INDEX__CONTRACT_ADDRESS = 15;\nglobal GENERATOR_INDEX__CONTRACT_LEAF = 16;\nglobal GENERATOR_INDEX__CALL_CONTEXT = 17;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM = 18;\nglobal GENERATOR_INDEX__CALL_STACK_ITEM_2 = 19;\nglobal GENERATOR_INDEX__L1_TO_L2_MESSAGE_SECRET = 20;\nglobal GENERATOR_INDEX__L2_TO_L1_MSG = 21;\nglobal GENERATOR_INDEX__TX_CONTEXT = 22;\nglobal GENERATOR_INDEX__PUBLIC_LEAF_INDEX = 23;\nglobal GENERATOR_INDEX__PUBLIC_DATA_LEAF = 24;\nglobal GENERATOR_INDEX__SIGNED_TX_REQUEST = 25;\nglobal GENERATOR_INDEX__GLOBAL_VARIABLES = 26;\nglobal GENERATOR_INDEX__PARTIAL_ADDRESS = 27;\nglobal GENERATOR_INDEX__BLOCK_HASH = 28;\nglobal GENERATOR_INDEX__SIDE_EFFECT = 29;\n// Indices with size ≤ 16\nglobal GENERATOR_INDEX__TX_REQUEST = 33;\nglobal GENERATOR_INDEX__SIGNATURE_PAYLOAD = 34;\n// Indices with size ≤ 44\nglobal GENERATOR_INDEX__VK = 41;\nglobal GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS = 42;\nglobal GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS = 43;\nglobal GENERATOR_INDEX__FUNCTION_ARGS = 44;\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/constants.nr"
+    },
+    "111": {
+      "source": "use crate::address::{AztecAddress, EthAddress};\nuse crate::mocked::VerificationKey;\nuse crate::abis::function_selector::FunctionSelector;\nuse crate::abis::function_leaf_preimage::FunctionLeafPreimage;\nuse crate::abis::new_contract_data::NewContractData as ContractLeafPreimage;\nuse crate::abis::function_data::FunctionData;\nuse crate::abis::side_effect::{SideEffect};\nuse crate::utils::uint256::U256;\nuse crate::utils::bounded_vec::BoundedVec;\nuse crate::constants::{\n        ARGS_HASH_CHUNK_COUNT,\n        ARGS_HASH_CHUNK_LENGTH,\n        CONTRACT_TREE_HEIGHT, \n        FUNCTION_TREE_HEIGHT, \n        NOTE_HASH_TREE_HEIGHT,\n        NUM_FIELDS_PER_SHA256,\n        GENERATOR_INDEX__SILOED_COMMITMENT,\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__VK,\n        GENERATOR_INDEX__CONSTRUCTOR,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__COMMITMENT_NONCE,\n        GENERATOR_INDEX__UNIQUE_COMMITMENT,\n        GENERATOR_INDEX__FUNCTION_ARGS,\n};\n\nuse dep::std::hash::{pedersen_hash_with_separator, sha256};\n\npub fn sha256_to_field<N>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256(bytes_to_hash);\n\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (sha256_hashed[15 - i] as Field) * v;\n        low = low + (sha256_hashed[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    let hash_in_a_field = low + high * v;\n\n    hash_in_a_field\n}\n\npub fn hash_args<N>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n        for i in 0..ARGS_HASH_CHUNK_COUNT {\n            let mut chunk_hash = 0;\n            let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n            if start_chunk_index < (args.len() as u32) {\n                let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n                for j in 0..ARGS_HASH_CHUNK_LENGTH {\n                    let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n                    if item_index < (args.len() as u32) {\n                        chunk_args[j] = args[item_index];\n                    }\n                }\n                chunk_hash = pedersen_hash(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS);\n            }\n            chunks_hashes[i] = chunk_hash;\n        }\n        pedersen_hash(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Checks that `value` is a member of a merkle tree with root `root` at position `index`\n// The witness being the `sibling_path`\npub fn assert_check_membership<N>(value: Field, index: Field, sibling_path: [Field; N], root: Field) {\n    let calculated_root = root_from_sibling_path(value, index, sibling_path);\n    assert(calculated_root == root, \"membership check failed\");\n}\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like \n// this because it means we never even need to consider cases where \n// the index is greater than p.\npub fn root_from_sibling_path<N>(leaf: Field, leaf_index: Field, sibling_path: [Field; N]) -> Field {\n    let mut node = leaf;\n    let indices = leaf_index.to_le_bits(N);\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\n// Calculate the function tree root from the sibling path and leaf preimage.\n//\n// TODO: The cpp code passes in components of the FunctionLeafPreimage and then \n// builds it up. We should build it up and then pass the leaf preimage as a parameter.\n// We can then choose to have a general method that takes in anything hashable\n// and deduplicate the logic in `contract_tree_root_from_siblings`\npub fn function_tree_root_from_siblings(\n    selector: FunctionSelector,\n    is_internal: bool,\n    is_private: bool,\n    vk_hash: Field,\n    acir_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT]\n) -> Field {\n    let function_leaf_preimage = FunctionLeafPreimage { selector, is_internal, is_private, vk_hash, acir_hash };\n\n    let function_leaf = function_leaf_preimage.hash();\n\n    let function_tree_root = root_from_sibling_path(function_leaf, function_leaf_index, function_leaf_sibling_path);\n\n    function_tree_root\n}\n\n// Calculate the contract tree root from the sibling path and leaf preimage.\npub fn contract_tree_root_from_siblings(\n    function_tree_root: Field,\n    storage_contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    contract_leaf_index: Field,\n    contract_leaf_sibling_path: [Field; CONTRACT_TREE_HEIGHT]\n) -> Field {\n    //TODO(Kev): if we use shorthand syntax here, we get an error as expected,\n    // since variable name is `storage_contract_address` but the span is incorrect.\n    let contract_leaf_preimage = ContractLeafPreimage { contract_address: storage_contract_address, portal_contract_address, function_tree_root };\n\n    let contract_leaf = contract_leaf_preimage.hash();\n\n    let computed_contract_tree_root = root_from_sibling_path(contract_leaf, contract_leaf_index, contract_leaf_sibling_path);\n\n    computed_contract_tree_root\n}\n\npub fn read_request_root_from_siblings(\n    read_request: Field,\n    leaf_index: Field,\n    sibling_path: [Field; NOTE_HASH_TREE_HEIGHT]\n) -> Field {\n    root_from_sibling_path(read_request, leaf_index, sibling_path)\n}\n\npub fn silo_commitment(address: AztecAddress, inner_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        inner_commitment\n    ],\n        GENERATOR_INDEX__SILOED_COMMITMENT\n    )\n}\n\npub fn silo_nullifier(address: AztecAddress, nullifier: Field) -> Field {\n    pedersen_hash(\n        [\n        address.to_field(),\n        nullifier\n    ],\n        GENERATOR_INDEX__OUTER_NULLIFIER\n    )\n}\n\nfn merkle_hash(left: Field, right: Field) -> Field {\n    pedersen_hash([left, right], 0)\n}\n\npub fn stdlib_recursion_verification_key_compress_native_vk(_vk: VerificationKey) -> Field {\n    // Original cpp code\n    // stdlib::recursion::verification_key<CT::bn254>::compress_native(private_call.vk, GeneratorIndex::VK);\n    // The above cpp method is only ever called on verification key, so it has been special cased here\n    let _hash_index = GENERATOR_INDEX__VK;\n    0\n}\n\n// TODO CPP uses blake2s for this\npub fn compute_new_contract_address_hash(new_contract_address: AztecAddress) -> Field {\n    dep::std::hash::pedersen_hash([new_contract_address.to_field()])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    rollup_version_id: Field,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    content: Field\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new(0);\n\n    let inputs = [\n        contract_address.to_field(), rollup_version_id, portal_contract_address.to_field(), chain_id, content\n    ];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes = inputs[i].to_be_bytes(32);\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage)\n}\n\npub fn compute_constructor_hash(\n    function_data: FunctionData,\n    args_hash: Field,\n    constructor_vk_hash: Field\n) -> Field {\n    let function_data_hash = function_data.hash();\n\n    pedersen_hash(\n        [\n        function_data_hash,\n        args_hash,\n        constructor_vk_hash\n    ],\n        GENERATOR_INDEX__CONSTRUCTOR\n    )\n}\n\n// Computes sha256 hash of 2 input hashes stored in 4 fields.\n// \n// This method is bn254 specific. Two fields is needed in order to \n// encode the sha256 output. It can be abstracted away with any 4-2 hash function.\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\n// Returning a Field would be desirable because then this can be replaced with \n// poseidon without changing the rest of the code\n//\npub fn accumulate_sha256(input: [U128; 4]) -> [Field; NUM_FIELDS_PER_SHA256] {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually \n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field \n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    //\n    // Concatenate 4 u128 bit integers into a byte array.\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..4 {\n        let input_as_bytes = input[offset].to_be_bytes();\n        for byte_index in 0..16 {\n            hash_input_flattened[offset * 16 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    let sha_digest = dep::std::hash::sha256(hash_input_flattened);\n\n    U256::from_bytes32(sha_digest).to_u128_limbs()\n}\n\npub fn compute_logs_hash(\n    previous_log_hash: [Field; 2],\n    current_log_hash: [Field; 2]\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n    accumulate_sha256(\n        [\n        U128::from_integer(previous_log_hash[0]),\n        U128::from_integer(previous_log_hash[1]),\n        U128::from_integer(current_log_hash[0]),\n        U128::from_integer(current_log_hash[1])\n    ]\n    )\n}\n\npub fn compute_commitment_nonce(first_nullifier: Field, commitment_index: Field) -> Field {\n    pedersen_hash(\n        [\n        first_nullifier,\n        commitment_index\n    ],\n        GENERATOR_INDEX__COMMITMENT_NONCE\n    )\n}\n\npub fn compute_unique_siloed_commitment(nonce: Field, siloed_commitment: Field) -> Field {\n    pedersen_hash(\n        [\n        nonce,\n        siloed_commitment\n    ],\n        GENERATOR_INDEX__UNIQUE_COMMITMENT\n    )\n}\n\npub fn compute_unique_siloed_commitments<N>(\n    first_nullifier: Field,\n    siloed_commitments: [SideEffect; N]\n) -> [SideEffect; N] {\n    let mut unique_siloed_commitments = [SideEffect::empty(); N];\n    for i in 0..N {\n        let siloed_commitment = siloed_commitments[i];\n        if siloed_commitment.value != 0 {\n            let nonce = compute_commitment_nonce(first_nullifier, i);\n            unique_siloed_commitments[i] = SideEffect {\n                value: compute_unique_siloed_commitment(nonce, siloed_commitment.value),\n                counter: siloed_commitment.counter\n                };\n        }\n    }\n    unique_siloed_commitments\n}\n\npub fn pedersen_hash<N>(inputs: [Field; N], hash_index: u32) -> Field {\n    dep::std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/hash.nr"
+    },
+    "126": {
+      "source": "pub fn field_from_bytes<N>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() as u32 < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/utils/field.nr"
+    },
+    "150": {
+      "source": "use crate::utils::field::field_from_bytes;\nuse dep::std::cmp::Eq;\n\nglobal SELECTOR_SIZE = 4;\n\nstruct FunctionSelector {\n    // 1st 4-bytes of abi-encoding of function.\n    inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n    fn eq(self, function_selector: FunctionSelector) -> bool {\n        function_selector.inner == self.inner\n    }\n}\n\nimpl FunctionSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n\n    pub fn from_u32(value: u32) -> Self {\n        Self {\n            inner : value,\n        }\n    }\n\n    pub fn from_field(value : Field) -> Self {\n        Self {\n            inner : value as u32,\n        }\n    }\n\n    pub fn from_signature<N>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = dep::std::hash::keccak256(bytes, bytes.len() as u32);\n\n        let mut selector_be_bytes = [0; SELECTOR_SIZE];\n        for i in 0..SELECTOR_SIZE {\n            selector_be_bytes[i] = hash[i];\n        }\n\n        FunctionSelector::from_field(field_from_bytes(selector_be_bytes, true))\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0] as u32\n        }\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/abis/function_selector.nr"
+    },
+    "160": {
+      "source": "use crate::{\n    constants::{\n        GENERATOR_INDEX__CONTRACT_ADDRESS,\n        GENERATOR_INDEX__PARTIAL_ADDRESS,\n    },\n    hash::pedersen_hash,\n    utils,\n    grumpkin_point::GrumpkinPoint,\n};\nuse dep::std::cmp::Eq;\nuse crate::traits::{Empty, ToField};\n\n// Aztec address\nstruct AztecAddress {\n    inner : Field\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(pub_key: GrumpkinPoint, partial_address: PartialAddress) -> AztecAddress {\n        AztecAddress::from_field(\n            pedersen_hash(\n                [pub_key.x, pub_key.y, partial_address.to_field()],\n                GENERATOR_INDEX__CONTRACT_ADDRESS\n            )\n        )\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n    \n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0]\n        }\n    }\n}\n\nstruct EthAddress{\n    inner : Field\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other : Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self {\n            inner : 0\n        }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl EthAddress{\n    pub fn zero() -> Self {\n        Self {\n            inner: 0\n        }\n    }\n\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self {\n            inner : result\n        }\n    }\n\n    pub fn serialize(self: Self) -> [Field; 1] {\n        [self.inner]\n    }\n\n    pub fn deserialize(fields: [Field; 1]) -> Self {\n        Self {\n            inner: fields[0]\n        }\n    }\n}\n\n// Partial address\nstruct PartialAddress {\n    inner : Field\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field : Field) -> Self {\n        Self {\n            inner : field\n        }\n    }\n\n    pub fn compute(contract_address_salt : Field, function_tree_root : Field, constructor_hash : Field) -> Self {\n        PartialAddress::from_field(\n            pedersen_hash([\n                // TODO why the zeroes?\n                0,\n                0,\n                contract_address_salt,\n                function_tree_root,\n                constructor_hash\n            ], GENERATOR_INDEX__PARTIAL_ADDRESS)\n        )\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/address.nr"
+    },
+    "163": {
+      "source": "use crate::{\n    constants::{\n        CONTRACT_STORAGE_READ_LENGTH,\n        GENERATOR_INDEX__PUBLIC_DATA_READ,\n    },\n    hash::pedersen_hash,\n};\nuse crate::traits::Empty;\n\nstruct StorageRead {\n    storage_slot: Field,\n    current_value: Field,\n}\n\nimpl Empty for StorageRead {   \n    fn empty() -> Self {\n        Self {\n            storage_slot: 0,\n            current_value: 0,\n        }\n    }\n}\n\nimpl StorageRead {\n\n    pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n        [self.storage_slot, self.current_value]\n    }\n\n    pub fn hash(self) -> Field {\n        pedersen_hash(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)\n    }\n\n    pub fn is_empty(self) -> bool {\n        self.storage_slot == 0\n    }\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/noir-protocol-circuits/src/crates/types/src/contrakt/storage_read.nr"
+    },
+    "167": {
+      "source": "use dep::std::option::Option;\nuse dep::aztec::context::PrivateContext;\nuse dep::aztec::note::note_getter_options::{NoteGetterOptions, SortOrder};\nuse dep::aztec::oracle::get_public_key::get_public_key;\nuse dep::aztec::state_vars::set::Set;\nuse crate::{\n    filter::filter_notes_min_sum,\n    value_note::{ValueNote, VALUE_NOTE_LEN},\n};\nuse dep::aztec::protocol_types::address::AztecAddress;\n\n// Sort the note values (0th field) in descending order.\n// Pick the fewest notes whose sum is equal to or greater than `amount`.\npub fn create_note_getter_options_for_decreasing_balance(amount: Field) -> NoteGetterOptions<ValueNote, VALUE_NOTE_LEN, Field> {\n    NoteGetterOptions::with_filter(filter_notes_min_sum, amount).sort(0, SortOrder.DESC)\n}\n\n// Creates a new note for the recipient.\n// Inserts it to the recipient's set of notes.\npub fn increment(balance: Set<ValueNote, VALUE_NOTE_LEN>, amount: Field, recipient: AztecAddress) {\n    let mut note = ValueNote::new(amount, recipient);\n    // Insert the new note to the owner's set of notes and emit the log if value is non-zero.\n    balance.insert(&mut note, amount != 0);\n}\n\n// Find some of the `owner`'s notes whose values add up to the `amount`.\n// Remove those notes.\n// If the value of the removed notes exceeds the requested `amount`, create a new note containing the excess value, so that exactly `amount` is removed.\n// Fail if the sum of the selected notes is less than the amount.\npub fn decrement(balance: Set<ValueNote, VALUE_NOTE_LEN>, amount: Field, owner: AztecAddress) {\n    let sum = decrement_by_at_most(balance, amount, owner);\n    assert(sum == amount, \"Balance too low\");\n}\n\n// Similar to `decrement`, except that it doesn't fail if the decremented amount is less than max_amount.\n// The motivation behind this function is that there is an upper-bound on the number of notes a function may\n// read and nullify. The requested decrementation `amount` might be spread across too many of the `owner`'s\n// notes to 'fit' within this upper-bound, so we might have to remove an amount less than `amount`. A common\n// pattern is to repeatedly call this function across many function calls, until enough notes have been nullified to\n// equal `amount`.\n//\n// It returns the decremented amount, which should be less than or equal to max_amount.\npub fn decrement_by_at_most(\n    balance: Set<ValueNote, VALUE_NOTE_LEN>,\n    max_amount: Field,\n    owner: AztecAddress\n) -> Field {\n    let options = create_note_getter_options_for_decreasing_balance(max_amount);\n    let opt_notes = balance.get_notes(options);\n\n    let mut decremented = 0;\n    for i in 0..opt_notes.len() {\n        if opt_notes[i].is_some() {\n            decremented += destroy_note(balance, owner, opt_notes[i].unwrap_unchecked());\n        }\n    }\n\n    // Add the change value back to the owner's balance.\n    let mut change_value = 0;\n    if decremented as u120 > max_amount as u120 {\n        change_value = decremented - max_amount;\n        decremented -= change_value;\n    }\n    increment(balance, change_value, owner);\n\n    decremented\n}\n\n// Removes the note from the owner's set of notes.\n// Returns the value of the destroyed note.\npub fn destroy_note(\n    balance: Set<ValueNote, VALUE_NOTE_LEN>,\n    owner: AztecAddress,\n    note: ValueNote\n) -> Field {\n    // Ensure the note is actually owned by the owner (to prevent user from generating a valid proof while\n    // spending someone else's notes).\n    assert(note.owner.eq(owner));\n\n    balance.remove(note);\n\n    note.value\n}\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/value-note/src/utils.nr"
+    },
+    "169": {
+      "source": "use dep::aztec::{\n    protocol_types::address::AztecAddress,\n    note::{\n        note_header::NoteHeader,\n        note_interface::NoteInterface,\n        utils::compute_note_hash_for_read_or_nullify,\n    },\n    oracle::{\n        rand::rand,\n        nullifier_key::get_nullifier_secret_key,\n        get_public_key::get_public_key,\n    },\n    log::emit_encrypted_log,\n    hash::pedersen_hash,\n    context::PrivateContext,\n};\n\nglobal VALUE_NOTE_LEN: Field = 3; // 3 plus a header.\n\n// docs:start:value-note-def\nstruct ValueNote {\n    value: Field,\n    owner: AztecAddress,\n    randomness: Field,\n    header: NoteHeader,\n}\n// docs:end:value-note-def\n\nimpl ValueNote {\n    pub fn new(value: Field, owner: AztecAddress) -> Self {\n        let randomness = rand();\n        let header = NoteHeader::empty();\n        ValueNote {\n            value,\n            owner,\n            randomness,\n            header,\n        }\n    }\n\n    pub fn serialize(self) -> [Field; VALUE_NOTE_LEN] {\n        [self.value, self.owner.to_field(), self.randomness]\n    }\n\n    pub fn deserialize(serialized_note: [Field; VALUE_NOTE_LEN]) -> Self {\n        ValueNote {\n            value: serialized_note[0],\n            owner: AztecAddress::from_field(serialized_note[1]),\n            randomness: serialized_note[2],\n            header: NoteHeader::empty(),\n        }\n    }\n\n    pub fn compute_note_hash(self) -> Field {\n        // TODO(#1205) Should use a non-zero generator index.\n        pedersen_hash(self.serialize(),0)\n    }\n\n    // docs:start:nullifier\n\n    pub fn compute_nullifier(self, context: &mut PrivateContext) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n        let secret = context.request_nullifier_secret_key(self.owner);\n        // TODO(#1205) Should use a non-zero generator index.\n        pedersen_hash([\n            note_hash_for_nullify,\n            secret.low,\n            secret.high,\n        ],0)\n    }\n\n    // docs:end:nullifier\n\n    pub fn compute_nullifier_without_context(self) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n        let secret = get_nullifier_secret_key(self.owner);\n        // TODO(#1205) Should use a non-zero generator index.\n        pedersen_hash([\n            note_hash_for_nullify,\n            secret.low,\n            secret.high,\n        ],0)\n    }\n\n    pub fn set_header(&mut self, header: NoteHeader) {\n        self.header = header;\n    }\n\n    // Broadcasts the note as an encrypted log on L1.\n    pub fn broadcast(self, context: &mut PrivateContext, slot: Field) {\n        let encryption_pub_key = get_public_key(self.owner);\n        emit_encrypted_log(\n            context,\n            (*context).this_address(),\n            slot,\n            encryption_pub_key,\n            self.serialize(),\n        );\n    }\n}\n\nfn deserialize(serialized_note: [Field; VALUE_NOTE_LEN]) -> ValueNote {\n    ValueNote::deserialize(serialized_note)\n}\n\nfn serialize(note: ValueNote) -> [Field; VALUE_NOTE_LEN] {\n    note.serialize()\n}\n\nfn compute_note_hash(note: ValueNote) -> Field {\n    note.compute_note_hash()\n}\n\nfn compute_nullifier(note: ValueNote, context: &mut PrivateContext) -> Field {\n    note.compute_nullifier(context)\n}\n\nfn compute_nullifier_without_context(note: ValueNote) -> Field {\n    note.compute_nullifier_without_context()\n}\n\nfn get_header(note: ValueNote) -> NoteHeader {\n    note.header\n}\n\nfn set_header(note: &mut ValueNote, header: NoteHeader) {\n    note.set_header(header)\n}\n\n// Broadcasts the note as an encrypted log on L1.\nfn broadcast(context: &mut PrivateContext, slot: Field, note: ValueNote) {\n    note.broadcast(context, slot);\n}\n\nglobal ValueNoteMethods = NoteInterface {\n    deserialize,\n    serialize,\n    compute_note_hash,\n    compute_nullifier,\n    compute_nullifier_without_context,\n    get_header,\n    set_header,\n    broadcast,\n};\n",
+      "path": "/home/santiago/Projects/aztec3-packages/yarn-project/aztec-nr/value-note/src/value_note.nr"
+    }
+  }
+}
diff --git a/yarn-project/circuits.js/package.json b/yarn-project/circuits.js/package.json
index e3f18a3ca83..9aabf460ce3 100644
--- a/yarn-project/circuits.js/package.json
+++ b/yarn-project/circuits.js/package.json
@@ -41,6 +41,7 @@
   "dependencies": {
     "@aztec/bb.js": "portal:../../barretenberg/ts",
     "@aztec/foundation": "workspace:^",
+    "@aztec/types": "workspace:^",
     "eslint": "^8.35.0",
     "lodash.chunk": "^4.2.0",
     "tslib": "^2.4.0"
diff --git a/yarn-project/circuits.js/src/abis/merkle_tree_calculator.ts b/yarn-project/circuits.js/src/abis/merkle_tree_calculator.ts
index a4de23b3911..3c8796d48da 100644
--- a/yarn-project/circuits.js/src/abis/merkle_tree_calculator.ts
+++ b/yarn-project/circuits.js/src/abis/merkle_tree_calculator.ts
@@ -5,10 +5,16 @@ import { pedersenHash } from '@aztec/foundation/crypto';
  */
 export class MerkleTreeCalculator {
   private zeroHashes: Buffer[];
-
-  constructor(private height: number, zeroLeaf = Buffer.alloc(32)) {
+  private hasher: (left: Buffer, right: Buffer) => Buffer;
+
+  constructor(
+    private height: number,
+    zeroLeaf = Buffer.alloc(32),
+    hasher = (left: Buffer, right: Buffer) => pedersenHash([left, right]),
+  ) {
+    this.hasher = hasher;
     this.zeroHashes = Array.from({ length: height }).reduce(
-      (acc: Buffer[], _, i) => [...acc, pedersenHash([acc[i], acc[i]])],
+      (acc: Buffer[], _, i) => [...acc, this.hasher(acc[i], acc[i])],
       [zeroLeaf],
     );
   }
@@ -26,7 +32,7 @@ export class MerkleTreeCalculator {
       for (let j = 0; j < leaves.length / 2; ++j) {
         const l = leaves[j * 2];
         const r = leaves[j * 2 + 1] || this.zeroHashes[i];
-        newLeaves[j] = pedersenHash([l, r]);
+        newLeaves[j] = this.hasher(l, r);
       }
       result = result.concat(new Array(numLeaves - leaves.length).fill(this.zeroHashes[i]), newLeaves);
       leaves = newLeaves;
@@ -47,7 +53,7 @@ export class MerkleTreeCalculator {
       for (; j < leaves.length / 2; ++j) {
         const l = leaves[j * 2];
         const r = leaves[j * 2 + 1] || this.zeroHashes[i];
-        leaves[j] = pedersenHash([l, r]);
+        leaves[j] = this.hasher(l, r);
       }
       leaves = leaves.slice(0, j);
     }
diff --git a/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap b/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap
new file mode 100644
index 00000000000..0491640d721
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/__snapshots__/contract_class.test.ts.snap
@@ -0,0 +1,48 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ContractClass creates a contract class from a contract compilation artifact 1`] = `
+"{
+  "version": 1,
+  "artifactHash": "0x0000000000000000000000000000000000000000000000000000000000001234",
+  "publicFunctions": [
+    {
+      "selector": {
+        "value": 2381782501
+      },
+      "bytecode": "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",
+      "isInternal": false
+    },
+    {
+      "selector": {
+        "value": 2603445359
+      },
+      "bytecode": "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",
+      "isInternal": false
+    }
+  ],
+  "privateFunctions": [
+    {
+      "selector": {
+        "value": 2432309179
+      },
+      "vkHash": "0x14190584f036fa06cf521e691f0afa86192d284cdc36e4b138c8d8f56b1a5afc",
+      "isInternal": false
+    },
+    {
+      "selector": {
+        "value": 283286945
+      },
+      "vkHash": "0x14190584f036fa06cf521e691f0afa86192d284cdc36e4b138c8d8f56b1a5afc",
+      "isInternal": false
+    },
+    {
+      "selector": {
+        "value": 332459554
+      },
+      "vkHash": "0x14190584f036fa06cf521e691f0afa86192d284cdc36e4b138c8d8f56b1a5afc",
+      "isInternal": false
+    }
+  ],
+  "packedBytecode": "0x"
+}"
+`;
diff --git a/yarn-project/circuits.js/src/contract/artifact_hash.test.ts b/yarn-project/circuits.js/src/contract/artifact_hash.test.ts
new file mode 100644
index 00000000000..e5584ba3904
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/artifact_hash.test.ts
@@ -0,0 +1,11 @@
+import { getSampleContractArtifact } from '../tests/fixtures.js';
+import { getArtifactHash } from './artifact_hash.js';
+
+describe('ArtifactHash', () => {
+  it('calculates the artifact hash', () => {
+    const artifact = getSampleContractArtifact();
+    expect(getArtifactHash(artifact).toString()).toMatchInlineSnapshot(
+      `"0x1cd31b12181cf7516720f4675ffea13c8c538dc4875232776adb8bbe8364ed5c"`,
+    );
+  });
+});
diff --git a/yarn-project/circuits.js/src/contract/artifact_hash.ts b/yarn-project/circuits.js/src/contract/artifact_hash.ts
new file mode 100644
index 00000000000..f1abc2ca1d2
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/artifact_hash.ts
@@ -0,0 +1,67 @@
+import { ContractArtifact, FunctionArtifact, FunctionSelector, FunctionType } from '@aztec/foundation/abi';
+import { sha256 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { numToUInt8 } from '@aztec/foundation/serialize';
+
+import { MerkleTreeCalculator } from '../abis/merkle_tree_calculator.js';
+
+const VERSION = 1;
+
+/**
+ * Returns the artifact hash of a given compiled contract artifact.
+ *
+ * ```
+ * private_functions_artifact_leaves = artifact.private_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * private_functions_artifact_tree_root = merkleize(private_functions_artifact_leaves)
+ *
+ * unconstrained_functions_artifact_leaves = artifact.unconstrained_functions.map fn =>
+ *   sha256(fn.selector, fn.metadata_hash, sha256(fn.bytecode))
+ * unconstrained_functions_artifact_tree_root = merkleize(unconstrained_functions_artifact_leaves)
+ *
+ * version = 1
+ * artifact_hash = sha256(
+ *   version,
+ *   private_functions_artifact_tree_root,
+ *   unconstrained_functions_artifact_tree_root,
+ *   artifact_metadata,
+ * )
+ * ```
+ * @param artifact - Artifact to calculate the hash for.
+ */
+export function getArtifactHash(artifact: ContractArtifact): Fr {
+  const privateFunctionRoot = getFunctionRoot(artifact, FunctionType.SECRET);
+  const unconstrainedFunctionRoot = getFunctionRoot(artifact, FunctionType.OPEN);
+  const metadataHash = getArtifactMetadataHash(artifact);
+  const preimage = [numToUInt8(VERSION), privateFunctionRoot, unconstrainedFunctionRoot, metadataHash];
+  return Fr.fromBufferReduce(sha256(Buffer.concat(preimage)));
+}
+
+function getArtifactMetadataHash(artifact: ContractArtifact) {
+  const metadata = { name: artifact.name, events: artifact.events }; // TODO(@spalladino): Should we use the sorted event selectors instead? They'd need to be unique for that.
+  return sha256(Buffer.from(JSON.stringify(metadata), 'utf-8'));
+}
+
+type FunctionArtifactWithSelector = FunctionArtifact & { selector: FunctionSelector };
+
+function getFunctionRoot(artifact: ContractArtifact, fnType: FunctionType) {
+  const leaves = getFunctionLeaves(artifact, fnType);
+  const height = Math.ceil(Math.log2(leaves.length));
+  const calculator = new MerkleTreeCalculator(height, Buffer.alloc(32), (l, r) => sha256(Buffer.concat([l, r])));
+  return calculator.computeTreeRoot(leaves);
+}
+
+function getFunctionLeaves(artifact: ContractArtifact, fnType: FunctionType) {
+  return artifact.functions
+    .filter(f => f.functionType === fnType)
+    .map(f => ({ ...f, selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters) }))
+    .sort((a, b) => a.selector.value - b.selector.value)
+    .map(getFunctionArtifactHash);
+}
+
+function getFunctionArtifactHash(fn: FunctionArtifactWithSelector): Buffer {
+  const bytecodeHash = sha256(Buffer.from(fn.bytecode, 'hex'));
+  const metadata = JSON.stringify(fn.returnTypes);
+  const metadataHash = sha256(Buffer.from(metadata, 'utf8'));
+  return sha256(Buffer.concat([numToUInt8(VERSION), fn.selector.toBuffer(), metadataHash, bytecodeHash]));
+}
diff --git a/yarn-project/circuits.js/src/contract/contract_class.test.ts b/yarn-project/circuits.js/src/contract/contract_class.test.ts
new file mode 100644
index 00000000000..e755f466009
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/contract_class.test.ts
@@ -0,0 +1,15 @@
+import { Fr } from '@aztec/foundation/fields';
+import { toFriendlyJSON } from '@aztec/foundation/serialize';
+
+import { getSampleContractArtifact } from '../tests/fixtures.js';
+import { createContractClassFromArtifact } from './contract_class.js';
+
+describe('ContractClass', () => {
+  it('creates a contract class from a contract compilation artifact', () => {
+    const contractClass = createContractClassFromArtifact({
+      ...getSampleContractArtifact(),
+      artifactHash: Fr.fromString('0x1234'),
+    });
+    expect(toFriendlyJSON(contractClass)).toMatchSnapshot();
+  });
+});
diff --git a/yarn-project/circuits.js/src/contract/contract_class.ts b/yarn-project/circuits.js/src/contract/contract_class.ts
new file mode 100644
index 00000000000..07e55da85e1
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/contract_class.ts
@@ -0,0 +1,45 @@
+import { ContractArtifact, FunctionSelector, FunctionType } from '@aztec/foundation/abi';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { ContractClass } from '@aztec/types/contracts';
+
+import chunk from 'lodash.chunk';
+
+import { GeneratorIndex } from '../constants.gen.js';
+
+/** Contract artifact including its artifact hash */
+type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+
+/**
+ * Creates a ContractClass from a contract compilation artifact with its artifact hash.
+ */
+export function createContractClassFromArtifact(artifact: ContractArtifactWithHash): ContractClass {
+  return {
+    version: 1,
+    artifactHash: artifact.artifactHash,
+    publicFunctions: artifact.functions
+      .filter(f => f.functionType === FunctionType.OPEN)
+      .map(f => ({
+        selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+        bytecode: Buffer.from(f.bytecode, 'base64'),
+        isInternal: f.isInternal,
+      })),
+    privateFunctions: artifact.functions
+      .filter(f => f.functionType === FunctionType.SECRET)
+      .map(f => ({
+        selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+        vkHash: getVerificationKeyHash(Buffer.from(f.verificationKey!, 'base64')),
+        isInternal: f.isInternal,
+      })),
+    packedBytecode: Buffer.alloc(0),
+  };
+}
+
+/**
+ * Calculates the hash of a verification key.
+ * TODO(@spalladino) Check this is the correct calculation of vkhash
+ * */
+function getVerificationKeyHash(vk: Buffer) {
+  const chunks = chunk(vk, 32).map(nums => Buffer.from(nums));
+  return Fr.fromBuffer(pedersenHash(chunks, GeneratorIndex.VK));
+}
diff --git a/yarn-project/circuits.js/src/contract/contract_class_id.test.ts b/yarn-project/circuits.js/src/contract/contract_class_id.test.ts
new file mode 100644
index 00000000000..a60a4894192
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/contract_class_id.test.ts
@@ -0,0 +1,34 @@
+import { Fr } from '@aztec/foundation/fields';
+import { ContractClass } from '@aztec/types/contracts';
+
+import { FunctionSelector, getContractClassId } from '../index.js';
+
+describe('ContractClass', () => {
+  describe('getContractClassId', () => {
+    it('calculates the contract class id', () => {
+      const contractClass: ContractClass = {
+        version: 1,
+        artifactHash: Fr.fromString('0x1234'),
+        packedBytecode: Buffer.from('123456789012345678901234567890', 'hex'),
+        privateFunctions: [
+          {
+            selector: FunctionSelector.fromString('0x12345678'),
+            vkHash: Fr.fromString('0x1234'),
+            isInternal: false,
+          },
+        ],
+        publicFunctions: [
+          {
+            selector: FunctionSelector.fromString('0x12345678'),
+            bytecode: Buffer.from('123456789012345678901234567890', 'hex'),
+            isInternal: false,
+          },
+        ],
+      };
+
+      expect(getContractClassId(contractClass).toString()).toMatchInlineSnapshot(
+        `"0x1b436781f84669144ec383d6ea5f49b05ccba5c6221ebeb86085443c2a859202"`,
+      );
+    });
+  });
+});
diff --git a/yarn-project/circuits.js/src/contract/contract_class_id.ts b/yarn-project/circuits.js/src/contract/contract_class_id.ts
new file mode 100644
index 00000000000..62882ed5b21
--- /dev/null
+++ b/yarn-project/circuits.js/src/contract/contract_class_id.ts
@@ -0,0 +1,78 @@
+import { pedersenHash, sha256 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { numToUInt8 } from '@aztec/foundation/serialize';
+import { ContractClass, PrivateFunction, PublicFunction } from '@aztec/types/contracts';
+
+import { MerkleTreeCalculator } from '../abis/merkle_tree_calculator.js';
+import { FUNCTION_TREE_HEIGHT, GeneratorIndex } from '../constants.gen.js';
+
+/**
+ * Returns the id of a contract class computed as its hash.
+ *
+ * ```
+ * version = 1
+ * private_function_leaves = private_functions.map(fn => pedersen([fn.function_selector as Field, fn.vk_hash], GENERATOR__FUNCTION_LEAF))
+ * private_functions_root = merkleize(private_function_leaves)
+ * bytecode_commitment = calculate_commitment(packed_bytecode)
+ * contract_class_id = pedersen([version, artifact_hash, private_functions_root, bytecode_commitment], GENERATOR__CLASS_IDENTIFIER)
+ * ```
+ * @param contractClass - Contract class.
+ * @returns The identifier.
+ */
+export function getContractClassId(contractClass: ContractClass): Fr {
+  const privateFunctionsRoot = getPrivateFunctionsRoot(contractClass.privateFunctions);
+  const publicFunctionsRoot = getPublicFunctionsRoot(contractClass.publicFunctions); // This should be removed once we drop public functions as first class citizens in the protocol
+  const bytecodeCommitment = getBytecodeCommitment(contractClass.packedBytecode);
+  return Fr.fromBuffer(
+    pedersenHash(
+      [
+        numToUInt8(contractClass.version),
+        contractClass.artifactHash.toBuffer(),
+        privateFunctionsRoot.toBuffer(),
+        publicFunctionsRoot.toBuffer(),
+        bytecodeCommitment.toBuffer(),
+      ],
+      GeneratorIndex.CONTRACT_LEAF, // TODO(@spalladino): Review all generator indices in this file
+    ),
+  );
+}
+
+// TODO(@spalladino): Replace with actual implementation
+function getBytecodeCommitment(bytecode: Buffer) {
+  return Fr.fromBufferReduce(sha256(bytecode));
+}
+
+// Memoize the merkle tree calculators to avoid re-computing the zero-hash for each level in each call
+let privateFunctionTreeCalculator: MerkleTreeCalculator | undefined;
+let publicFunctionTreeCalculator: MerkleTreeCalculator | undefined;
+
+const PRIVATE_FUNCTION_SIZE = 2;
+const PUBLIC_FUNCTION_SIZE = 2;
+
+function getPrivateFunctionsRoot(fns: PrivateFunction[]): Fr {
+  const privateFunctionLeaves = fns.map(fn =>
+    pedersenHash(
+      [fn.selector, fn.vkHash].map(x => x.toBuffer()),
+      GeneratorIndex.FUNCTION_LEAF,
+    ),
+  );
+  if (!privateFunctionTreeCalculator) {
+    const functionTreeZeroLeaf = pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(Buffer.alloc(32)));
+    privateFunctionTreeCalculator = new MerkleTreeCalculator(FUNCTION_TREE_HEIGHT, functionTreeZeroLeaf);
+  }
+  return Fr.fromBuffer(privateFunctionTreeCalculator.computeTreeRoot(privateFunctionLeaves));
+}
+
+function getPublicFunctionsRoot(fns: PublicFunction[]): Fr {
+  const publicFunctionLeaves = fns.map(fn =>
+    pedersenHash(
+      [fn.selector, getBytecodeCommitment(fn.bytecode)].map(x => x.toBuffer()),
+      GeneratorIndex.FUNCTION_LEAF,
+    ),
+  );
+  if (!publicFunctionTreeCalculator) {
+    const functionTreeZeroLeaf = pedersenHash(new Array(PUBLIC_FUNCTION_SIZE).fill(Buffer.alloc(32)));
+    publicFunctionTreeCalculator = new MerkleTreeCalculator(FUNCTION_TREE_HEIGHT, functionTreeZeroLeaf);
+  }
+  return Fr.fromBuffer(publicFunctionTreeCalculator.computeTreeRoot(publicFunctionLeaves));
+}
diff --git a/yarn-project/circuits.js/src/contract/index.ts b/yarn-project/circuits.js/src/contract/index.ts
index 38bc67a9e52..389c0596500 100644
--- a/yarn-project/circuits.js/src/contract/index.ts
+++ b/yarn-project/circuits.js/src/contract/index.ts
@@ -1,2 +1,5 @@
 export * from './contract_deployment_info.js';
 export * from './contract_tree/index.js';
+export * from './contract_class_id.js';
+export * from './contract_class.js';
+export * from './artifact_hash.js';
diff --git a/yarn-project/circuits.js/src/tests/fixtures.ts b/yarn-project/circuits.js/src/tests/fixtures.ts
new file mode 100644
index 00000000000..135bd6edbe5
--- /dev/null
+++ b/yarn-project/circuits.js/src/tests/fixtures.ts
@@ -0,0 +1,13 @@
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { loadContractArtifact } from '@aztec/types/abi';
+import { NoirCompiledContract } from '@aztec/types/noir';
+
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+export function getSampleContractArtifact(): ContractArtifact {
+  const path = resolve(dirname(fileURLToPath(import.meta.url)), '../../fixtures/Benchmarking.test.json');
+  const content = JSON.parse(readFileSync(path).toString()) as NoirCompiledContract;
+  return loadContractArtifact(content);
+}
diff --git a/yarn-project/circuits.js/tsconfig.json b/yarn-project/circuits.js/tsconfig.json
index 63f8ab3e9f7..831130c7c84 100644
--- a/yarn-project/circuits.js/tsconfig.json
+++ b/yarn-project/circuits.js/tsconfig.json
@@ -8,6 +8,9 @@
   "references": [
     {
       "path": "../foundation"
+    },
+    {
+      "path": "../types"
     }
   ],
   "include": ["src"]
diff --git a/yarn-project/foundation/src/abi/selector.ts b/yarn-project/foundation/src/abi/selector.ts
index ff70d868f03..0a6a0eb661c 100644
--- a/yarn-project/foundation/src/abi/selector.ts
+++ b/yarn-project/foundation/src/abi/selector.ts
@@ -1,6 +1,8 @@
 import { fromHex, toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { BufferReader } from '@aztec/foundation/serialize';
 
+import { randomBytes } from 'crypto';
+
 import { keccak } from '../crypto/keccak/index.js';
 import { Fr } from '../fields/index.js';
 import { type ABIParameter } from './abi.js';
@@ -15,7 +17,7 @@ abstract class Selector {
 
   constructor(/** Value of the selector */ public value: number) {
     if (value > 2 ** (Selector.SIZE * 8) - 1) {
-      throw new Error(`selector must fit in ${Selector.SIZE} bytes.`);
+      throw new Error(`Selector must fit in ${Selector.SIZE} bytes (got value ${value}).`);
     }
   }
 
@@ -154,6 +156,13 @@ export class FunctionSelector extends Selector {
     // console.log(`selector for ${signature} is ${selector}`);
     return selector;
   }
+
+  /**
+   * Creates a random instance.
+   */
+  static random() {
+    return FunctionSelector.fromBuffer(randomBytes(Selector.SIZE));
+  }
 }
 
 /** Event selector branding */
diff --git a/yarn-project/foundation/src/eth-address/index.ts b/yarn-project/foundation/src/eth-address/index.ts
index 76587ecab26..7594a9ad345 100644
--- a/yarn-project/foundation/src/eth-address/index.ts
+++ b/yarn-project/foundation/src/eth-address/index.ts
@@ -232,7 +232,7 @@ export class EthAddress {
    */
   static fromBuffer(buffer: Buffer | BufferReader): EthAddress {
     const reader = BufferReader.asReader(buffer);
-    return new EthAddress(reader.readBuffer());
+    return new EthAddress(reader.readBytes(32));
   }
 
   /**
diff --git a/yarn-project/foundation/src/serialize/buffer_reader.ts b/yarn-project/foundation/src/serialize/buffer_reader.ts
index b54a2d1b52b..903abcab077 100644
--- a/yarn-project/foundation/src/serialize/buffer_reader.ts
+++ b/yarn-project/foundation/src/serialize/buffer_reader.ts
@@ -65,6 +65,17 @@ export class BufferReader {
     return this.buffer.readUInt16BE(this.index - 2);
   }
 
+  /**
+   * Reads a 8-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 1 byte after reading the number.
+   *
+   * @returns The read 8 bit value.
+   */
+  public readUInt8(): number {
+    this.index += 1;
+    return this.buffer.readUInt8(this.index - 1);
+  }
+
   /**
    * Reads and returns the next boolean value from the buffer.
    * Advances the internal index by 1, treating the byte at the current index as a boolean value.
diff --git a/yarn-project/pxe/package.json b/yarn-project/pxe/package.json
index 82bf35b49e6..3ade258964c 100644
--- a/yarn-project/pxe/package.json
+++ b/yarn-project/pxe/package.json
@@ -51,6 +51,7 @@
     "viem": "^1.2.5"
   },
   "devDependencies": {
+    "@aztec/noir-contracts": "workspace:^",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/lodash.omit": "^4.5.7",
diff --git a/yarn-project/pxe/src/database/contracts/contract_artifact_db.ts b/yarn-project/pxe/src/database/contracts/contract_artifact_db.ts
new file mode 100644
index 00000000000..e49d96c061c
--- /dev/null
+++ b/yarn-project/pxe/src/database/contracts/contract_artifact_db.ts
@@ -0,0 +1,19 @@
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+
+/**
+ * PXE database for managing contract artifacts.
+ */
+export interface ContractArtifactDatabase {
+  /**
+   * Adds a new contract artifact to the database or updates an existing one.
+   * @param id - Id of the corresponding contract class.
+   * @param contract - Contract artifact to add.
+   */
+  addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void>;
+  /**
+   * Gets a contract artifact given its resulting contract class id.
+   * @param id - Contract class id for the given artifact.
+   */
+  getContractArtifact(id: Fr): Promise<ContractArtifact | undefined>;
+}
diff --git a/yarn-project/pxe/src/database/contracts/contract_instance_db.ts b/yarn-project/pxe/src/database/contracts/contract_instance_db.ts
new file mode 100644
index 00000000000..30dd44bed9e
--- /dev/null
+++ b/yarn-project/pxe/src/database/contracts/contract_instance_db.ts
@@ -0,0 +1,18 @@
+import { AztecAddress } from '@aztec/circuits.js';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+/**
+ * PXE database for managing contract instances.
+ */
+export interface ContractInstanceDatabase {
+  /**
+   * Adds a new contract to the db or updates an existing one.
+   * @param contract - Contract to insert.
+   */
+  addContractInstance(contract: ContractInstanceWithAddress): Promise<void>;
+  /**
+   * Gets a contract given its address.
+   * @param address - Address of the contract.
+   */
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+}
diff --git a/yarn-project/pxe/src/database/kv_pxe_database.ts b/yarn-project/pxe/src/database/kv_pxe_database.ts
index a6216e9be06..2b1956efa98 100644
--- a/yarn-project/pxe/src/database/kv_pxe_database.ts
+++ b/yarn-project/pxe/src/database/kv_pxe_database.ts
@@ -1,7 +1,10 @@
 import { ContractDao, MerkleTreeId, NoteFilter, PublicKey } from '@aztec/circuit-types';
 import { AztecAddress, BlockHeader, CompleteAddress } from '@aztec/circuits.js';
+import { ContractArtifact } from '@aztec/foundation/abi';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { AztecArray, AztecKVStore, AztecMap, AztecMultiMap, AztecSingleton } from '@aztec/kv-store';
+import { contractArtifactFromBuffer, contractArtifactToBuffer } from '@aztec/types/abi';
+import { ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
 
 import { DeferredNoteDao } from './deferred_note_dao.js';
 import { NoteDao } from './note_dao.js';
@@ -36,6 +39,8 @@ export class KVPxeDatabase implements PxeDatabase {
   #deferredNotes: AztecArray<Buffer>;
   #deferredNotesByContract: AztecMultiMap<string, number>;
   #syncedBlockPerPublicKey: AztecMap<string, number>;
+  #contractArtifacts: AztecMap<string, Buffer>;
+  #contractInstances: AztecMap<string, Buffer>;
   #db: AztecKVStore;
 
   constructor(db: AztecKVStore) {
@@ -47,6 +52,8 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#authWitnesses = db.createMap('auth_witnesses');
     this.#capsules = db.createArray('capsules');
     this.#contracts = db.createMap('contracts');
+    this.#contractArtifacts = db.createMap('contract_artifacts');
+    this.#contractInstances = db.createMap('contracts_instances');
 
     this.#synchronizedBlock = db.createSingleton('block_header');
     this.#syncedBlockPerPublicKey = db.createMap('synced_block_per_public_key');
@@ -63,6 +70,28 @@ export class KVPxeDatabase implements PxeDatabase {
     this.#deferredNotesByContract = db.createMultiMap('deferred_notes_by_contract');
   }
 
+  public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
+    await this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract));
+  }
+
+  getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
+    const contract = this.#contractArtifacts.get(id.toString());
+    // TODO(@spalladino): AztecMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
+    return Promise.resolve(contract && contractArtifactFromBuffer(Buffer.from(contract)));
+  }
+
+  async addContractInstance(contract: ContractInstanceWithAddress): Promise<void> {
+    await this.#contractInstances.set(
+      contract.address.toString(),
+      new SerializableContractInstance(contract).toBuffer(),
+    );
+  }
+
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const contract = this.#contractInstances.get(address.toString());
+    return Promise.resolve(contract && SerializableContractInstance.fromBuffer(contract).withAddress(address));
+  }
+
   async addAuthWitness(messageHash: Fr, witness: Fr[]): Promise<void> {
     await this.#authWitnesses.set(
       messageHash.toString(),
diff --git a/yarn-project/pxe/src/database/memory_db.ts b/yarn-project/pxe/src/database/memory_db.ts
index 174d80677c3..5390c654b94 100644
--- a/yarn-project/pxe/src/database/memory_db.ts
+++ b/yarn-project/pxe/src/database/memory_db.ts
@@ -1,8 +1,10 @@
 import { MerkleTreeId, NoteFilter } from '@aztec/circuit-types';
 import { BlockHeader, CompleteAddress, PublicKey } from '@aztec/circuits.js';
+import { ContractArtifact } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { MemoryContractDatabase } from '../contract_database/index.js';
 import { DeferredNoteDao } from './deferred_note_dao.js';
@@ -28,10 +30,33 @@ export class MemoryDB extends MemoryContractDatabase implements PxeDatabase {
   // We are using a stack to keep track of the capsules that are passed to the contract.
   private capsuleStack: Fr[][] = [];
 
+  private contractArtifacts = new Map<string, ContractArtifact>();
+  private contractInstances = new Map<string, ContractInstanceWithAddress>();
+
   constructor(logSuffix?: string) {
     super(createDebugLogger(logSuffix ? 'aztec:memory_db_' + logSuffix : 'aztec:memory_db'));
   }
 
+  public addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
+    this.contractArtifacts.set(id.toString(), contract);
+    return Promise.resolve();
+  }
+
+  public getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
+    const contract = this.contractArtifacts.get(id.toString());
+    return Promise.resolve(contract);
+  }
+
+  public addContractInstance(contract: ContractInstanceWithAddress): Promise<void> {
+    this.contractInstances.set(contract.address.toString(), contract);
+    return Promise.resolve();
+  }
+
+  public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const contract = this.contractInstances.get(address.toString());
+    return Promise.resolve(contract);
+  }
+
   /**
    * Add a auth witness to the database.
    * @param messageHash - The message hash.
diff --git a/yarn-project/pxe/src/database/pxe_database.ts b/yarn-project/pxe/src/database/pxe_database.ts
index b08e9932f7c..537069d7e78 100644
--- a/yarn-project/pxe/src/database/pxe_database.ts
+++ b/yarn-project/pxe/src/database/pxe_database.ts
@@ -3,6 +3,8 @@ import { BlockHeader, CompleteAddress, PublicKey } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
+import { ContractArtifactDatabase } from './contracts/contract_artifact_db.js';
+import { ContractInstanceDatabase } from './contracts/contract_instance_db.js';
 import { DeferredNoteDao } from './deferred_note_dao.js';
 import { NoteDao } from './note_dao.js';
 
@@ -10,7 +12,7 @@ import { NoteDao } from './note_dao.js';
  * A database interface that provides methods for retrieving, adding, and removing transactional data related to Aztec
  * addresses, storage slots, and nullifiers.
  */
-export interface PxeDatabase extends ContractDatabase {
+export interface PxeDatabase extends ContractDatabase, ContractArtifactDatabase, ContractInstanceDatabase {
   /**
    * Add a auth witness to the database.
    * @param messageHash - The message hash.
diff --git a/yarn-project/pxe/src/database/pxe_database_test_suite.ts b/yarn-project/pxe/src/database/pxe_database_test_suite.ts
index 5464ef98dde..5f0a7ebccbf 100644
--- a/yarn-project/pxe/src/database/pxe_database_test_suite.ts
+++ b/yarn-project/pxe/src/database/pxe_database_test_suite.ts
@@ -1,6 +1,8 @@
 import { INITIAL_L2_BLOCK_NUM, MerkleTreeId, NoteFilter, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, BlockHeader, CompleteAddress } from '@aztec/circuits.js';
 import { Fr, Point } from '@aztec/foundation/fields';
+import { BenchmarkingContractArtifact } from '@aztec/noir-contracts/Benchmarking';
+import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { NoteDao } from './note_dao.js';
 import { randomNoteDao } from './note_dao.test.js';
@@ -216,5 +218,21 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         expect(await database.getCompleteAddress(CompleteAddress.random().address)).toBeUndefined();
       });
     });
+
+    describe('contracts', () => {
+      it('stores a contract artifact', async () => {
+        const artifact = BenchmarkingContractArtifact;
+        const id = Fr.random();
+        await database.addContractArtifact(id, artifact);
+        await expect(database.getContractArtifact(id)).resolves.toEqual(artifact);
+      });
+
+      it('stores a contract instance', async () => {
+        const address = AztecAddress.random();
+        const instance = SerializableContractInstance.random().withAddress(address);
+        await database.addContractInstance(instance);
+        await expect(database.getContractInstance(address)).resolves.toEqual(instance);
+      });
+    });
   });
 }
diff --git a/yarn-project/pxe/src/pxe_service/pxe_service.ts b/yarn-project/pxe/src/pxe_service/pxe_service.ts
index 0d732971158..b7e3ac38a08 100644
--- a/yarn-project/pxe/src/pxe_service/pxe_service.ts
+++ b/yarn-project/pxe/src/pxe_service/pxe_service.ts
@@ -44,6 +44,9 @@ import {
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   PartialAddress,
   PublicCallRequest,
+  createContractClassFromArtifact,
+  getArtifactHash,
+  getContractClassId,
 } from '@aztec/circuits.js';
 import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis';
 import { DecodedReturn, encodeArguments } from '@aztec/foundation/abi';
@@ -52,6 +55,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { NodeInfo } from '@aztec/types/interfaces';
 
 import { PXEServiceConfig, getPackageInfo } from '../config/index.js';
@@ -209,6 +213,7 @@ export class PXEService implements PXE {
   public async addContracts(contracts: DeployedContract[]) {
     const contractDaos = contracts.map(c => new ContractDao(c.artifact, c.completeAddress, c.portalContract));
     await Promise.all(contractDaos.map(c => this.db.addContract(c)));
+    await this.addArtifactsAndInstancesFromDeployedContracts(contracts);
     for (const contract of contractDaos) {
       const contractAztecAddress = contract.completeAddress.address;
       const portalInfo =
@@ -218,6 +223,28 @@ export class PXEService implements PXE {
     }
   }
 
+  private async addArtifactsAndInstancesFromDeployedContracts(contracts: DeployedContract[]) {
+    for (const contract of contracts) {
+      const artifact = contract.artifact;
+      const artifactHash = getArtifactHash(artifact);
+      const contractClassId = getContractClassId(createContractClassFromArtifact({ ...artifact, artifactHash }));
+
+      // TODO: Properly derive this from the DeployedContract once we update address calculation
+      const contractInstance: ContractInstanceWithAddress = {
+        version: 1,
+        salt: Fr.ZERO,
+        contractClassId,
+        initializationHash: Fr.ZERO,
+        portalContractAddress: contract.portalContract,
+        publicKeysHash: contract.completeAddress.publicKey.x,
+        address: contract.completeAddress.address,
+      };
+
+      await this.db.addContractArtifact(contractClassId, artifact);
+      await this.db.addContractInstance(contractInstance);
+    }
+  }
+
   public async getContracts(): Promise<AztecAddress[]> {
     return (await this.db.getContracts()).map(c => c.completeAddress.address);
   }
diff --git a/yarn-project/pxe/tsconfig.json b/yarn-project/pxe/tsconfig.json
index f78f8c2e76a..4af0483e9f2 100644
--- a/yarn-project/pxe/tsconfig.json
+++ b/yarn-project/pxe/tsconfig.json
@@ -35,6 +35,9 @@
     },
     {
       "path": "../types"
+    },
+    {
+      "path": "../noir-contracts"
     }
   ],
   "include": ["src"]
diff --git a/yarn-project/types/package.json b/yarn-project/types/package.json
index f8e42023289..4bdfbc0801e 100644
--- a/yarn-project/types/package.json
+++ b/yarn-project/types/package.json
@@ -7,6 +7,7 @@
   "types": "./dest/index.d.ts",
   "exports": {
     "./abi": "./dest/abi/index.js",
+    "./contracts": "./dest/contracts/index.js",
     "./interfaces": "./dest/interfaces/index.js",
     "./membership": "./dest/sibling-path/index.js",
     "./noir": "./dest/noir/index.js"
diff --git a/yarn-project/types/src/abi/contract_artifact.ts b/yarn-project/types/src/abi/contract_artifact.ts
index 1df2e3dbac1..221fb7c80c4 100644
--- a/yarn-project/types/src/abi/contract_artifact.ts
+++ b/yarn-project/types/src/abi/contract_artifact.ts
@@ -10,6 +10,26 @@ import {
 import { NoirCompiledContract } from '../noir/index.js';
 import { mockVerificationKey } from './mocked_keys.js';
 
+/**
+ * Serializes a contract artifact to a buffer for storage.
+ * @param artifact - Artifact to serialize.
+ * @returns A buffer.
+ */
+export function contractArtifactToBuffer(artifact: ContractArtifact): Buffer {
+  // TODO(@spalladino): More efficient serialization
+  return Buffer.from(JSON.stringify(artifact), 'utf8');
+}
+
+/**
+ * Deserializes a contract artifact from storage.
+ * @param buffer - Buffer to deserialize.
+ * @returns Deserialized artifact.
+ */
+export function contractArtifactFromBuffer(buffer: Buffer): ContractArtifact {
+  // TODO(@spalladino): More efficient serialization
+  return JSON.parse(buffer.toString('utf8')) as ContractArtifact;
+}
+
 /**
  * Gets nargo build output and returns a valid contract artifact instance.
  * @param input - Input object as generated by nargo compile.
diff --git a/yarn-project/types/src/contracts/contract_class.test.ts b/yarn-project/types/src/contracts/contract_class.test.ts
new file mode 100644
index 00000000000..8521217473c
--- /dev/null
+++ b/yarn-project/types/src/contracts/contract_class.test.ts
@@ -0,0 +1,8 @@
+import { SerializableContractClass } from './contract_class.js';
+
+describe('ContractClass', () => {
+  it('can serialize and deserialize a contract class', () => {
+    const contractClass = SerializableContractClass.random();
+    expect(SerializableContractClass.fromBuffer(contractClass.toBuffer())).toEqual(contractClass);
+  });
+});
diff --git a/yarn-project/types/src/contracts/contract_class.ts b/yarn-project/types/src/contracts/contract_class.ts
new file mode 100644
index 00000000000..b8444e166df
--- /dev/null
+++ b/yarn-project/types/src/contracts/contract_class.ts
@@ -0,0 +1,175 @@
+import { FunctionSelector } from '@aztec/foundation/abi';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
+
+const VERSION = 1 as const;
+
+export interface ContractClass {
+  /** Version of the contract class. */
+  version: typeof VERSION;
+  /** Hash of the contract artifact. The specification of this hash is not enforced by the protocol. Should include commitments to unconstrained code and compilation metadata. Intended to be used by clients to verify that an off-chain fetched artifact matches a registered class. */
+  artifactHash: Fr;
+  /** List of individual private functions, constructors included. */
+  privateFunctions: PrivateFunction[];
+  /** List of individual public functions. Should be removed once we switch to the AVM where all public bytecode is bundled together. */
+  publicFunctions: PublicFunction[];
+  /** Packed bytecode representation of the AVM bytecode for all public functions in this contract. Unused for now, see `publicFunctions`. */
+  packedBytecode: Buffer;
+}
+
+/** Serializable implementation of the contract class interface. */
+export class SerializableContractClass implements ContractClass {
+  /** Version identifier. Initially one, bumped for any changes to the contract class struct. */
+  public readonly version = VERSION;
+
+  public readonly artifactHash: Fr;
+  public readonly packedBytecode: Buffer;
+  public readonly privateFunctions: SerializablePrivateFunction[];
+  public readonly publicFunctions: SerializablePublicFunction[];
+
+  constructor(contractClass: ContractClass) {
+    if (contractClass.version !== VERSION) {
+      throw new Error(`Unexpected contract class version ${contractClass.version}`);
+    }
+    this.privateFunctions = contractClass.privateFunctions.map(x => new SerializablePrivateFunction(x));
+    this.publicFunctions = contractClass.publicFunctions.map(x => new SerializablePublicFunction(x));
+    this.artifactHash = contractClass.artifactHash;
+    this.packedBytecode = contractClass.packedBytecode;
+  }
+
+  /** Returns a copy of this object with its id included. */
+  withId(id: Fr): ContractClassWithId {
+    return { ...this, id };
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(
+      numToUInt8(this.version),
+      this.artifactHash,
+      this.privateFunctions.length,
+      this.privateFunctions,
+      this.publicFunctions.length,
+      this.publicFunctions,
+      this.packedBytecode.length,
+      this.packedBytecode,
+    );
+  }
+
+  static fromBuffer(bufferOrReader: BufferReader | Buffer) {
+    const reader = BufferReader.asReader(bufferOrReader);
+    return new SerializableContractClass({
+      version: reader.readUInt8() as typeof VERSION,
+      artifactHash: reader.readObject(Fr),
+      privateFunctions: reader.readVector(SerializablePrivateFunction),
+      publicFunctions: reader.readVector(SerializablePublicFunction),
+      packedBytecode: reader.readBuffer(),
+    });
+  }
+
+  static random() {
+    return new SerializableContractClass({
+      version: VERSION,
+      artifactHash: Fr.random(),
+      privateFunctions: [SerializablePrivateFunction.random()],
+      publicFunctions: [SerializablePublicFunction.random()],
+      packedBytecode: randomBytes(32),
+    });
+  }
+}
+
+export interface PrivateFunction {
+  /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
+  selector: FunctionSelector;
+  /** Hash of the verification key associated to this private function. */
+  vkHash: Fr;
+  /**
+   * Whether the function is internal.
+   * @deprecated To be reimplemented as an app-level macro.
+   */
+  isInternal: boolean;
+}
+
+/** Private function in a Contract Class. */
+export class SerializablePrivateFunction {
+  public readonly selector: FunctionSelector;
+  public readonly vkHash: Fr;
+  public readonly isInternal: boolean;
+
+  constructor(privateFunction: PrivateFunction) {
+    this.selector = privateFunction.selector;
+    this.vkHash = privateFunction.vkHash;
+    this.isInternal = privateFunction.isInternal;
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.selector, this.vkHash, this.isInternal);
+  }
+
+  static fromBuffer(bufferOrReader: BufferReader | Buffer): PrivateFunction {
+    const reader = BufferReader.asReader(bufferOrReader);
+    return new SerializablePrivateFunction({
+      selector: reader.readObject(FunctionSelector),
+      vkHash: reader.readObject(Fr),
+      isInternal: reader.readBoolean(),
+    });
+  }
+
+  static random() {
+    return new SerializablePrivateFunction({
+      selector: FunctionSelector.random(),
+      vkHash: Fr.random(),
+      isInternal: false,
+    });
+  }
+}
+
+export interface PublicFunction {
+  /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
+  selector: FunctionSelector;
+  /** Public bytecode. */
+  bytecode: Buffer;
+  /**
+   * Whether the function is internal.
+   * @deprecated To be reimplemented as an app-level macro.
+   */
+  isInternal: boolean;
+}
+
+/**
+ * Public function in a Contract Class. Use `packedBytecode` in the parent class once supported.
+ */
+export class SerializablePublicFunction {
+  public readonly selector: FunctionSelector;
+  public readonly bytecode: Buffer;
+  public readonly isInternal: boolean;
+
+  constructor(publicFunction: PublicFunction) {
+    this.selector = publicFunction.selector;
+    this.bytecode = publicFunction.bytecode;
+    this.isInternal = publicFunction.isInternal;
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.selector, this.bytecode.length, this.bytecode, this.isInternal);
+  }
+
+  static fromBuffer(bufferOrReader: BufferReader | Buffer): PublicFunction {
+    const reader = BufferReader.asReader(bufferOrReader);
+    return new SerializablePublicFunction({
+      selector: reader.readObject(FunctionSelector),
+      bytecode: reader.readBuffer(),
+      isInternal: reader.readBoolean(),
+    });
+  }
+
+  static random() {
+    return new SerializablePublicFunction({
+      selector: FunctionSelector.random(),
+      bytecode: randomBytes(32),
+      isInternal: false,
+    });
+  }
+}
+
+export type ContractClassWithId = ContractClass & { id: Fr };
diff --git a/yarn-project/types/src/contracts/contract_instance.test.ts b/yarn-project/types/src/contracts/contract_instance.test.ts
new file mode 100644
index 00000000000..86818076f93
--- /dev/null
+++ b/yarn-project/types/src/contracts/contract_instance.test.ts
@@ -0,0 +1,8 @@
+import { SerializableContractInstance } from './contract_instance.js';
+
+describe('ContractInstance', () => {
+  it('can serialize and deserialize an instance', () => {
+    const instance = SerializableContractInstance.random();
+    expect(SerializableContractInstance.fromBuffer(instance.toBuffer())).toEqual(instance);
+  });
+});
diff --git a/yarn-project/types/src/contracts/contract_instance.ts b/yarn-project/types/src/contracts/contract_instance.ts
new file mode 100644
index 00000000000..71ac496c076
--- /dev/null
+++ b/yarn-project/types/src/contracts/contract_instance.ts
@@ -0,0 +1,83 @@
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
+
+const VERSION = 1 as const;
+
+/** A contract instance is a concrete deployment of a contract class. A contract instance always references a contract class, which dictates what code it executes when called. A contract instance has state (both private and public), as well as an address that acts as its identifier. A contract instance can be called into. */
+export interface ContractInstance {
+  /** Version identifier. Initially one, bumped for any changes to the contract instance struct. */
+  version: typeof VERSION;
+  /** User-generated pseudorandom value for uniqueness. */
+  salt: Fr;
+  /** Identifier of the contract class for this instance. */
+  contractClassId: Fr;
+  /** Hash of the selector and arguments to the constructor. */
+  initializationHash: Fr;
+  /** Optional address of the L1 portal contract. */
+  portalContractAddress: EthAddress;
+  /** Optional hash of the struct of public keys used for encryption and nullifying by this contract. */
+  publicKeysHash: Fr;
+}
+
+export type ContractInstanceWithAddress = ContractInstance & { address: AztecAddress };
+
+export class SerializableContractInstance {
+  public readonly version = VERSION;
+  public readonly salt: Fr;
+  public readonly contractClassId: Fr;
+  public readonly initializationHash: Fr;
+  public readonly portalContractAddress: EthAddress;
+  public readonly publicKeysHash: Fr;
+
+  constructor(instance: ContractInstance) {
+    if (instance.version !== VERSION) {
+      throw new Error(`Unexpected contract class version ${instance.version}`);
+    }
+    this.salt = instance.salt;
+    this.contractClassId = instance.contractClassId;
+    this.initializationHash = instance.initializationHash;
+    this.portalContractAddress = instance.portalContractAddress;
+    this.publicKeysHash = instance.publicKeysHash;
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(
+      numToUInt8(this.version),
+      this.salt,
+      this.contractClassId,
+      this.initializationHash,
+      this.portalContractAddress,
+      this.publicKeysHash,
+    );
+  }
+
+  /** Returns a copy of this object with its address included. */
+  withAddress(address: AztecAddress): ContractInstanceWithAddress {
+    return { ...this, address };
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(bufferOrReader);
+    return new SerializableContractInstance({
+      version: reader.readUInt8() as typeof VERSION,
+      salt: reader.readObject(Fr),
+      contractClassId: reader.readObject(Fr),
+      initializationHash: reader.readObject(Fr),
+      portalContractAddress: reader.readObject(EthAddress),
+      publicKeysHash: reader.readObject(Fr),
+    });
+  }
+
+  static random() {
+    return new SerializableContractInstance({
+      version: VERSION,
+      salt: Fr.random(),
+      contractClassId: Fr.random(),
+      initializationHash: Fr.random(),
+      portalContractAddress: EthAddress.random(),
+      publicKeysHash: Fr.random(),
+    });
+  }
+}
diff --git a/yarn-project/types/src/contracts/index.ts b/yarn-project/types/src/contracts/index.ts
new file mode 100644
index 00000000000..b90e91afc35
--- /dev/null
+++ b/yarn-project/types/src/contracts/index.ts
@@ -0,0 +1,2 @@
+export * from './contract_class.js';
+export * from './contract_instance.js';
diff --git a/yarn-project/yarn.lock b/yarn-project/yarn.lock
index 53d6be96445..a3ed1d89239 100644
--- a/yarn-project/yarn.lock
+++ b/yarn-project/yarn.lock
@@ -117,6 +117,7 @@ __metadata:
     "@aztec/foundation": "workspace:^"
     "@aztec/kv-store": "workspace:^"
     "@aztec/l1-artifacts": "workspace:^"
+    "@aztec/types": "workspace:^"
     "@jest/globals": ^29.5.0
     "@types/debug": ^4.1.7
     "@types/jest": ^29.5.0
@@ -325,6 +326,7 @@ __metadata:
   dependencies:
     "@aztec/bb.js": "portal:../../barretenberg/ts"
     "@aztec/foundation": "workspace:^"
+    "@aztec/types": "workspace:^"
     "@jest/globals": ^29.5.0
     "@types/jest": ^29.5.0
     "@types/lodash.chunk": ^4.2.7
@@ -755,6 +757,7 @@ __metadata:
     "@aztec/key-store": "workspace:^"
     "@aztec/kv-store": "workspace:^"
     "@aztec/noir-compiler": "workspace:^"
+    "@aztec/noir-contracts": "workspace:^"
     "@aztec/noir-protocol-circuits": "workspace:^"
     "@aztec/types": "workspace:^"
     "@jest/globals": ^29.5.0