@aztec/pxe 0.28.1 → 0.30.0

package/src/pxe_service/pxe_service.ts

@@ -1,10 +1,6 @@
 import {
   AuthWitness,
   AztecNode,
-  ContractDao,
-  ContractData,
-  DeployedContract,
-  ExtendedContractData,
   ExtendedNote,
   FunctionCall,
   GetUnencryptedLogsResponse,
@@ -35,12 +31,11 @@ import {
   PartialAddress,
   PrivateKernelTailCircuitPublicInputs,
   PublicCallRequest,
-  computeArtifactHash,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { DecodedReturn, encodeArguments } from '@aztec/foundation/abi';
+import { ContractArtifact, DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
@@ -218,36 +213,46 @@ export class PXEService implements PXE {
     return Promise.resolve(recipient);
   }
 
-  public async addContracts(contracts: DeployedContract[]) {
-    const contractDaos = contracts.map(c => new ContractDao(c.artifact, c.instance));
-    await Promise.all(contractDaos.map(c => this.db.addContract(c)));
-    await this.addArtifactsAndInstancesFromDeployedContracts(contracts);
-    for (const contract of contractDaos) {
-      const instance = contract.instance;
-      const contractAztecAddress = instance.address;
-      const hasPortal = instance.portalContractAddress && !instance.portalContractAddress.isZero();
-      const portalInfo = hasPortal ? ` with portal ${instance.portalContractAddress.toChecksumString()}` : '';
-      this.log.info(`Added contract ${contract.name} at ${contractAztecAddress}${portalInfo}`);
-      await this.synchronizer.reprocessDeferredNotesForContract(contractAztecAddress);
-    }
+  public async registerContractClass(artifact: ContractArtifact): Promise<void> {
+    const contractClassId = computeContractClassId(getContractClassFromArtifact(artifact));
+    await this.db.addContractArtifact(contractClassId, artifact);
+    this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
   }
 
-  private async addArtifactsAndInstancesFromDeployedContracts(contracts: DeployedContract[]) {
-    for (const contract of contracts) {
-      const artifact = contract.artifact;
-      const artifactHash = computeArtifactHash(artifact);
-      const contractClassId = computeContractClassId(getContractClassFromArtifact({ ...artifact, artifactHash }));
+  public async registerContract(contract: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact }) {
+    const { instance } = contract;
+    let { artifact } = contract;
+
+    if (artifact) {
+      // If the user provides an artifact, validate it against the expected class id and register it
+      const contractClassId = computeContractClassId(getContractClassFromArtifact(artifact));
+      if (!contractClassId.equals(instance.contractClassId)) {
+        throw new Error(
+          `Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.contractClassId})`,
+        );
+      }
       await this.db.addContractArtifact(contractClassId, artifact);
-      await this.db.addContractInstance(contract.instance);
+    } else {
+      // Otherwise, make sure there is an artifact already registered for that class id
+      artifact = await this.db.getContractArtifact(instance.contractClassId);
+      if (!artifact) {
+        throw new Error(
+          `Missing contract artifact for class id ${instance.contractClassId} for contract ${instance.address}`,
+        );
+      }
     }
+
+    this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()}`);
+    await this.db.addContractInstance(instance);
+    await this.synchronizer.reprocessDeferredNotesForContract(instance.address);
   }
 
-  public async getContracts(): Promise<AztecAddress[]> {
-    return (await this.db.getContracts()).map(c => c.instance.address);
+  public getContracts(): Promise<AztecAddress[]> {
+    return this.db.getContractsAddresses();
   }
 
   public async getPublicStorageAt(contract: AztecAddress, slot: Fr) {
-    if ((await this.getContractData(contract)) === undefined) {
+    if (!(await this.getContractInstance(contract))) {
       throw new Error(`Contract ${contract.toString()} is not deployed`);
     }
     return await this.node.getPublicStorageAt(contract, slot);
@@ -382,9 +387,6 @@ export class PXEService implements PXE {
     if (!txRequest.functionData.isPrivate) {
       throw new Error(`Public entrypoints are not allowed`);
     }
-    if (txRequest.functionData.isInternal === undefined) {
-      throw new Error(`Unspecified internal are not allowed`);
-    }
 
     // all simulations must be serialized w.r.t. the synchronizer
     return await this.jobQueue.put(async () => {
@@ -443,14 +445,6 @@ export class PXEService implements PXE {
     return await this.node.getBlockNumber();
   }
 
-  public async getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return await this.node.getExtendedContractData(contractAddress);
-  }
-
-  public async getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return await this.node.getContractData(contractAddress);
-  }
-
   /**
    * Gets unencrypted logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
@@ -657,9 +651,13 @@ export class PXEService implements PXE {
         if (contract) {
           err.enrichWithContractName(parsedContractAddress, contract.name);
           selectors.forEach(selector => {
-            const functionArtifact = contract.functions.find(f => f.selector.toString() === selector);
+            const functionArtifact = contract.functions.find(f => FunctionSelector.fromString(selector).equals(f));
             if (functionArtifact) {
-              err.enrichWithFunctionName(parsedContractAddress, functionArtifact.selector, functionArtifact.name);
+              err.enrichWithFunctionName(
+                parsedContractAddress,
+                FunctionSelector.fromNameAndParameters(functionArtifact),
+                functionArtifact.name,
+              );
             }
           });
         }
@@ -749,4 +747,8 @@ export class PXEService implements PXE {
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }
+
+  public async isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
+    return !!(await this.node.getContract(address));
+  }
 }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -1,4 +1,10 @@
-import { DeployedContract, PXE, TxExecutionRequest, randomDeployedContract } from '@aztec/circuit-types';
+import {
+  PXE,
+  TxExecutionRequest,
+  randomContractArtifact,
+  randomContractInstanceWithAddress,
+  randomDeployedContract,
+} from '@aztec/circuit-types';
 import {
   AztecAddress,
   CompleteAddress,
@@ -7,6 +13,7 @@ import {
   INITIAL_L2_BLOCK_NUM,
   Point,
   TxContext,
+  getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { ConstantKeyPair } from '@aztec/key-store';
@@ -82,16 +89,40 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('successfully adds a contract', async () => {
-      const contracts: DeployedContract[] = [randomDeployedContract(), randomDeployedContract()];
-      await pxe.addContracts(contracts);
+      const contracts = [randomDeployedContract(), randomDeployedContract()];
+      for (const contract of contracts) {
+        await pxe.registerContract(contract);
+      }
 
       const expectedContractAddresses = contracts.map(contract => contract.instance.address);
       const contractAddresses = await pxe.getContracts();
-
-      // check if all the contracts were returned
       expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
     });
 
+    it('registers a class and adds a contract for it', async () => {
+      const artifact = randomContractArtifact();
+      const contractClass = getContractClassFromArtifact(artifact);
+      const contractClassId = contractClass.id;
+      const instance = randomContractInstanceWithAddress({ contractClassId });
+
+      await pxe.registerContractClass(artifact);
+      expect(await pxe.getContractClass(contractClassId)).toEqual(contractClass);
+
+      await pxe.registerContract({ instance });
+      expect(await pxe.getContractInstance(instance.address)).toEqual(instance);
+    });
+
+    it('refuses to register a contract with a class that has not been registered', async () => {
+      const instance = randomContractInstanceWithAddress();
+      await expect(pxe.registerContract({ instance })).rejects.toThrow(/Missing contract artifact/i);
+    });
+
+    it('refuses to register a contract with an artifact with mismatching class id', async () => {
+      const artifact = randomContractArtifact();
+      const instance = randomContractInstanceWithAddress();
+      await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
+    });
+
     it('throws when simulating a tx targeting public entrypoint', async () => {
       const functionData = FunctionData.empty();
       functionData.isPrivate = false;
@@ -119,7 +150,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       );
     });
 
-    // Note: Not testing `getExtendedContractData`, `getContractData` and `getUnencryptedLogs` here as these
+    // Note: Not testing `getContractData` and `getUnencryptedLogs` here as these
     //       functions only call AztecNode and these methods are frequently used by the e2e tests.
 
     it('successfully gets a block number', async () => {

package/src/simulator_oracle/index.ts

@@ -16,7 +16,7 @@ import {
   Header,
   L1_TO_L2_MSG_TREE_HEIGHT,
 } from '@aztec/circuits.js';
-import { FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
+import { FunctionArtifactWithDebugMetadata, getFunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { DBOracle, KeyPair, MessageLoadOracleInputs } from '@aztec/simulator';
 import { ContractInstance } from '@aztec/types/contracts';
@@ -111,16 +111,9 @@ export class SimulatorOracle implements DBOracle {
     contractAddress: AztecAddress,
     functionName: string,
   ): Promise<FunctionArtifactWithDebugMetadata | undefined> {
-    const artifact = await this.contractDataOracle.getFunctionArtifactByName(contractAddress, functionName);
-    if (!artifact) {
-      return;
-    }
-
-    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, artifact.selector);
-    return {
-      ...artifact,
-      debug,
-    };
+    const instance = await this.contractDataOracle.getContractInstance(contractAddress);
+    const artifact = await this.contractDataOracle.getContractArtifact(instance.contractClassId);
+    return artifact && getFunctionArtifactWithDebugMetadata(artifact, functionName);
   }
 
   async getPortalContractAddress(contractAddress: AztecAddress): Promise<EthAddress> {
@@ -129,16 +122,18 @@ export class SimulatorOracle implements DBOracle {
 
   /**
    * Retrieves the L1ToL2Message associated with a specific entry key
-   * Throws an error if the entry key is not found
    *
+   * @throws If the entry key is not found
    * @param entryKey - The key of the message to be retrieved
    * @returns A promise that resolves to the message data, a sibling path and the
    *          index of the message in the l1ToL2MessageTree
    */
   async getL1ToL2MembershipWitness(entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    const messageAndIndex = await this.aztecNode.getL1ToL2MessageAndIndex(entryKey);
-    const index = messageAndIndex.index;
-    const siblingPath = await this.aztecNode.getL1ToL2MessageSiblingPath('latest', index);
+    const response = await this.aztecNode.getL1ToL2MessageMembershipWitness('latest', entryKey);
+    if (!response) {
+      throw new Error(`No L1 to L2 message found for entry key ${entryKey.toString()}`);
+    }
+    const [index, siblingPath] = response;
     return new MessageLoadOracleInputs(index, siblingPath);
   }
 

package/dest/contract_database/index.d.ts

@@ -1,2 +0,0 @@
-export * from './memory_contract_database.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/contract_database/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract_database/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dest/contract_database/index.js

@@ -1,2 +0,0 @@
-export * from './memory_contract_database.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZGF0YWJhc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQyJ9

package/dest/contract_database/memory_contract_database.d.ts

@@ -1,43 +0,0 @@
-import { ContractDao, ContractDatabase } from '@aztec/circuit-types';
-import { FunctionSelector } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { DebugLogger } from '@aztec/foundation/log';
-/**
- * The MemoryContractDatabase class serves as an in-memory implementation of the ContractDatabase interface.
- * It allows for storing and retrieving contract data, such as ContractDao objects and associated function bytecodes,
- * within a contracts array. This class is particularly useful for testing and development purposes where a
- * persistent storage may not be required.
- */
-export declare class MemoryContractDatabase implements ContractDatabase {
-    protected log: DebugLogger;
-    private contracts;
-    constructor(log: DebugLogger);
-    /**
-     * Adds a new ContractDao instance to the memory-based contract database.
-     * The function stores the contract in an array and returns a resolved promise indicating successful addition.
-     *
-     * @param contract - The ContractDao instance to be added to the memory database.
-     * @returns A Promise that resolves when the contract is successfully added.
-     */
-    addContract(contract: ContractDao): Promise<void>;
-    /**
-     * Retrieve a ContractDao instance with the specified AztecAddress from the in-memory contracts list.
-     * Returns the first match found or undefined if no contract with the given address is found.
-     *
-     * @param address - The AztecAddress to search for in the stored contracts.
-     * @returns A Promise resolving to the ContractDao instance matching the given address or undefined.
-     */
-    getContract(address: AztecAddress): Promise<ContractDao | undefined>;
-    getContracts(): Promise<ContractDao[]>;
-    /**
-     * Retrieve the bytecode associated with a given contract address and function selector.
-     * This function searches through the stored contracts to find a matching contract and function,
-     * then returns the corresponding bytecode. If no match is found, it returns undefined.
-     *
-     * @param contractAddress - The AztecAddress representing the contract address to look for.
-     * @param selector - The function selector.
-     * @returns A Promise that resolves to the bytecode of the matching function or undefined if not found.
-     */
-    getCode(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
-}
-//# sourceMappingURL=memory_contract_database.d.ts.map

package/dest/contract_database/memory_contract_database.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory_contract_database.d.ts","sourceRoot":"","sources":["../../src/contract_database/memory_contract_database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IAGjD,SAAS,CAAC,GAAG,EAAE,WAAW;IAFtC,OAAO,CAAC,SAAS,CAAqB;gBAEhB,GAAG,EAAE,WAAW;IAEtC;;;;;;OAMG;IACI,WAAW,CAAC,QAAQ,EAAE,WAAW;IAMxC;;;;;;OAMG;IACI,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAIpE,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAI7C;;;;;;;;OAQG;IACU,OAAO,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB;CAI/E"}

package/dest/contract_database/memory_contract_database.js

@@ -1,51 +0,0 @@
-/**
- * The MemoryContractDatabase class serves as an in-memory implementation of the ContractDatabase interface.
- * It allows for storing and retrieving contract data, such as ContractDao objects and associated function bytecodes,
- * within a contracts array. This class is particularly useful for testing and development purposes where a
- * persistent storage may not be required.
- */
-export class MemoryContractDatabase {
-    constructor(log) {
-        this.log = log;
-        this.contracts = [];
-    }
-    /**
-     * Adds a new ContractDao instance to the memory-based contract database.
-     * The function stores the contract in an array and returns a resolved promise indicating successful addition.
-     *
-     * @param contract - The ContractDao instance to be added to the memory database.
-     * @returns A Promise that resolves when the contract is successfully added.
-     */
-    addContract(contract) {
-        this.log(`Adding contract ${contract.instance.address.toString()}`);
-        this.contracts.push(contract);
-        return Promise.resolve();
-    }
-    /**
-     * Retrieve a ContractDao instance with the specified AztecAddress from the in-memory contracts list.
-     * Returns the first match found or undefined if no contract with the given address is found.
-     *
-     * @param address - The AztecAddress to search for in the stored contracts.
-     * @returns A Promise resolving to the ContractDao instance matching the given address or undefined.
-     */
-    getContract(address) {
-        return Promise.resolve(this.contracts.find(c => c.instance.address.equals(address)));
-    }
-    getContracts() {
-        return Promise.resolve(this.contracts);
-    }
-    /**
-     * Retrieve the bytecode associated with a given contract address and function selector.
-     * This function searches through the stored contracts to find a matching contract and function,
-     * then returns the corresponding bytecode. If no match is found, it returns undefined.
-     *
-     * @param contractAddress - The AztecAddress representing the contract address to look for.
-     * @param selector - The function selector.
-     * @returns A Promise that resolves to the bytecode of the matching function or undefined if not found.
-     */
-    async getCode(contractAddress, selector) {
-        const contract = await this.getContract(contractAddress);
-        return contract?.functions.find(f => f.selector.equals(selector))?.bytecode;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5X2NvbnRyYWN0X2RhdGFiYXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2RhdGFiYXNlL21lbW9yeV9jb250cmFjdF9kYXRhYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQTs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxzQkFBc0I7SUFHakMsWUFBc0IsR0FBZ0I7UUFBaEIsUUFBRyxHQUFILEdBQUcsQ0FBYTtRQUY5QixjQUFTLEdBQWtCLEVBQUUsQ0FBQztJQUVHLENBQUM7SUFFMUM7Ozs7OztPQU1HO0lBQ0ksV0FBVyxDQUFDLFFBQXFCO1FBQ3RDLElBQUksQ0FBQyxHQUFHLENBQUMsbUJBQW1CLFFBQVEsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNwRSxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUM5QixPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksV0FBVyxDQUFDLE9BQXFCO1FBQ3RDLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkYsQ0FBQztJQUVNLFlBQVk7UUFDakIsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSSxLQUFLLENBQUMsT0FBTyxDQUFDLGVBQTZCLEVBQUUsUUFBMEI7UUFDNUUsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ3pELE9BQU8sUUFBUSxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFLFFBQVEsQ0FBQztJQUM5RSxDQUFDO0NBQ0YifQ==

package/src/contract_database/index.ts

@@ -1 +0,0 @@
-export * from './memory_contract_database.js';

package/src/contract_database/memory_contract_database.ts

@@ -1,58 +0,0 @@
-import { ContractDao, ContractDatabase } from '@aztec/circuit-types';
-import { FunctionSelector } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { DebugLogger } from '@aztec/foundation/log';
-
-/**
- * The MemoryContractDatabase class serves as an in-memory implementation of the ContractDatabase interface.
- * It allows for storing and retrieving contract data, such as ContractDao objects and associated function bytecodes,
- * within a contracts array. This class is particularly useful for testing and development purposes where a
- * persistent storage may not be required.
- */
-export class MemoryContractDatabase implements ContractDatabase {
-  private contracts: ContractDao[] = [];
-
-  constructor(protected log: DebugLogger) {}
-
-  /**
-   * Adds a new ContractDao instance to the memory-based contract database.
-   * The function stores the contract in an array and returns a resolved promise indicating successful addition.
-   *
-   * @param contract - The ContractDao instance to be added to the memory database.
-   * @returns A Promise that resolves when the contract is successfully added.
-   */
-  public addContract(contract: ContractDao) {
-    this.log(`Adding contract ${contract.instance.address.toString()}`);
-    this.contracts.push(contract);
-    return Promise.resolve();
-  }
-
-  /**
-   * Retrieve a ContractDao instance with the specified AztecAddress from the in-memory contracts list.
-   * Returns the first match found or undefined if no contract with the given address is found.
-   *
-   * @param address - The AztecAddress to search for in the stored contracts.
-   * @returns A Promise resolving to the ContractDao instance matching the given address or undefined.
-   */
-  public getContract(address: AztecAddress): Promise<ContractDao | undefined> {
-    return Promise.resolve(this.contracts.find(c => c.instance.address.equals(address)));
-  }
-
-  public getContracts(): Promise<ContractDao[]> {
-    return Promise.resolve(this.contracts);
-  }
-
-  /**
-   * Retrieve the bytecode associated with a given contract address and function selector.
-   * This function searches through the stored contracts to find a matching contract and function,
-   * then returns the corresponding bytecode. If no match is found, it returns undefined.
-   *
-   * @param contractAddress - The AztecAddress representing the contract address to look for.
-   * @param selector - The function selector.
-   * @returns A Promise that resolves to the bytecode of the matching function or undefined if not found.
-   */
-  public async getCode(contractAddress: AztecAddress, selector: FunctionSelector) {
-    const contract = await this.getContract(contractAddress);
-    return contract?.functions.find(f => f.selector.equals(selector))?.bytecode;
-  }
-}