@aztec/sequencer-client 0.28.1 → 0.30.0

package/src/sequencer/processed_tx.ts

@@ -11,6 +11,7 @@ import {
   PublicKernelCircuitPublicInputs,
   SideEffect,
   SideEffectLinkedToNoteHash,
+  ValidationRequests,
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
@@ -109,6 +110,7 @@ export function getPreviousOutputAndProof(
   } else {
     const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
       tx.data.aggregationObject,
+      ValidationRequests.empty(),
       PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
       PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
       tx.data.constants,

package/src/sequencer/public_processor.ts

@@ -1,9 +1,10 @@
-import { ContractDataSource, L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
+import { L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
 import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
 import { GlobalVariables, Header } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { ContractDataSource } from '@aztec/types/contracts';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 import { EmptyPublicProver } from '../prover/empty.js';

package/src/sequencer/sequencer.ts

@@ -12,10 +12,12 @@ import { WorldStateStatus, WorldStateSynchronizer } from '@aztec/world-state';
 import { BlockBuilder } from '../block_builder/index.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { L1Publisher } from '../publisher/l1-publisher.js';
+import { WorldStatePublicDB } from '../simulator/public_executor.js';
 import { ceilPowerOfTwo } from '../utils.js';
 import { SequencerConfig } from './config.js';
 import { ProcessedTx } from './processed_tx.js';
 import { PublicProcessorFactory } from './public_processor.js';
+import { TxValidator } from './tx_validator.js';
 
 /**
  * Sequencer client
@@ -47,6 +49,7 @@ export class Sequencer {
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
     config: SequencerConfig = {},
+    private gasPortalAddress = EthAddress.ZERO,
     private log = createDebugLogger('aztec:sequencer'),
   ) {
     this.updateConfig(config);
@@ -171,8 +174,20 @@ export class Sequencer {
       );
 
       // Filter out invalid txs
+      const trees = this.worldState.getLatest();
+      const txValidator = new TxValidator(
+        {
+          getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
+            return trees.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+          },
+        },
+        new WorldStatePublicDB(trees),
+        this.gasPortalAddress,
+        newGlobalVariables,
+      );
+
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-      const validTxs = await this.takeValidTxs(pendingTxs, newGlobalVariables);
+      const validTxs = await this.takeValidTxs(pendingTxs, txValidator);
       if (validTxs.length < this.minTxsPerBLock) {
         return;
       }
@@ -193,7 +208,7 @@ export class Sequencer {
       // public functions emitting nullifiers would pass earlier check but fail here.
       // Note that we're checking all nullifiers generated in the private execution twice,
       // we could store the ones already checked and skip them here as an optimization.
-      const processedValidTxs = await this.takeValidTxs(processedTxs, newGlobalVariables);
+      const processedValidTxs = await this.takeValidTxs(processedTxs, txValidator);
 
       if (processedValidTxs.length === 0) {
         this.log('No txs processed correctly to build block. Exiting');
@@ -202,12 +217,10 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      const newModelL1ToL2Messages = await this.l1ToL2MessageSource.getNewL1ToL2Messages(BigInt(newBlockNumber));
-
       // Get l1 to l2 messages from the contract
       this.log('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.getPendingL1ToL2EntryKeys();
-      this.log('Successfully retrieved L1 to L2 messages from contract');
+      const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
+      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
 
       // Build the new block by running the rollup circuits
       this.log(`Assembling block with txs ${processedValidTxs.map(tx => tx.hash).join(', ')}`);
@@ -216,7 +229,7 @@ export class Sequencer {
 
       const emptyTx = processor.makeEmptyProcessedTx();
       const [rollupCircuitsDuration, block] = await elapsed(() =>
-        this.buildBlock(processedValidTxs, newModelL1ToL2Messages, l1ToL2Messages, emptyTx, newGlobalVariables),
+        this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
       );
 
       this.log(`Assembled block ${block.number}`, {
@@ -253,47 +266,14 @@ export class Sequencer {
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], globalVariables: GlobalVariables): Promise<T[]> {
-    const validTxs: T[] = [];
-    const txsToDelete = [];
-    const thisBlockNullifiers: Set<bigint> = new Set();
-
-    // Process txs until we get to maxTxsPerBlock, rejecting double spends in the process
-    for (const tx of txs) {
-      if (tx.data.constants.txContext.chainId.value !== globalVariables.chainId.value) {
-        this.log(
-          `Deleting tx for incorrect chain ${tx.data.constants.txContext.chainId.toString()}, tx hash ${Tx.getHash(
-            tx,
-          )}`,
-        );
-        txsToDelete.push(tx);
-        continue;
-      }
-      if (await this.isTxDoubleSpend(tx)) {
-        this.log(`Deleting double spend tx ${Tx.getHash(tx)}`);
-        txsToDelete.push(tx);
-        continue;
-      } else if (this.isTxDoubleSpendSameBlock(tx, thisBlockNullifiers)) {
-        // We don't drop these txs from the p2p pool immediately since they become valid
-        // again if the current block fails to be published for some reason.
-        this.log(`Skipping tx with double-spend for this same block ${Tx.getHash(tx)}`);
-        continue;
-      }
-
-      tx.data.end.newNullifiers.forEach(n => thisBlockNullifiers.add(n.value.toBigInt()));
-      tx.data.endNonRevertibleData.newNullifiers.forEach(n => thisBlockNullifiers.add(n.value.toBigInt()));
-      validTxs.push(tx);
-      if (validTxs.length >= this.maxTxsPerBlock) {
-        break;
-      }
-    }
-
-    // Make sure we remove these from the tx pool so we do not consider it again
-    if (txsToDelete.length > 0) {
-      await this.p2pClient.deleteTxs(Tx.getHashes([...txsToDelete]));
+  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator): Promise<T[]> {
+    const [valid, invalid] = await validator.validateTxs(txs);
+    if (invalid.length > 0) {
+      this.log(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
+      await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
     }
 
-    return validTxs;
+    return valid.slice(0, this.maxTxsPerBlock);
   }
 
   /**
@@ -314,16 +294,14 @@ export class Sequencer {
   /**
    * Pads the set of txs to a power of two and assembles a block by calling the block builder.
    * @param txs - Processed txs to include in the next block.
-   * @param newModelL1ToL2Messages - L1 to L2 messages emitted by the new inbox.
-   * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
+   * @param l1ToL2Messages - L1 to L2 messages to be part of the block.
    * @param emptyTx - Empty tx to repeat at the end of the block to pad to a power of two.
    * @param globalVariables - Global variables to use in the block.
    * @returns The new block.
    */
   protected async buildBlock(
     txs: ProcessedTx[],
-    newModelL1ToL2Messages: Fr[], // TODO(#4492): Rename this when purging the old inbox
-    newL1ToL2Messages: Fr[], // TODO(#4492): Nuke this when purging the old inbox
+    l1ToL2Messages: Fr[],
     emptyTx: ProcessedTx,
     globalVariables: GlobalVariables,
   ) {
@@ -332,74 +310,10 @@ export class Sequencer {
     const emptyTxCount = txsTargetSize - txs.length;
 
     const allTxs = [...txs, ...times(emptyTxCount, () => emptyTx)];
-    this.log(`Building block ${globalVariables.blockNumber}`);
-
-    const [block] = await this.blockBuilder.buildL2Block(
-      globalVariables,
-      allTxs,
-      newModelL1ToL2Messages,
-      newL1ToL2Messages,
-    );
-    return block;
-  }
-
-  /**
-   * Calls the archiver to pull upto `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` entry keys
-   * (archiver returns the top messages sorted by fees)
-   * @returns An array of L1 to L2 messages' entryKeys
-   */
-  protected async getPendingL1ToL2EntryKeys(): Promise<Fr[]> {
-    return await this.l1ToL2MessageSource.getPendingL1ToL2EntryKeys();
-  }
-
-  /**
-   * Returns true if one of the tx nullifiers exist on the block being built.
-   * @param tx - The tx to test.
-   * @param thisBlockNullifiers - The nullifiers added so far.
-   */
-  protected isTxDoubleSpendSameBlock(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): boolean {
-    // We only consider non-empty nullifiers
-    const newNullifiers = [
-      ...tx.data.endNonRevertibleData.newNullifiers.filter(n => !n.isEmpty()),
-      ...tx.data.end.newNullifiers.filter(n => !n.isEmpty()),
-    ];
-
-    for (const nullifier of newNullifiers) {
-      if (thisBlockNullifiers.has(nullifier.value.toBigInt())) {
-        return true;
-      }
-    }
-    return false;
-  }
+    this.log(`Building block ${globalVariables.blockNumber.toBigInt()}`);
 
-  /**
-   * Returns true if one of the transaction nullifiers exist.
-   * Nullifiers prevent double spends in a private context.
-   * @param tx - The transaction.
-   * @returns Whether this is a problematic double spend that the L1 contract would reject.
-   */
-  protected async isTxDoubleSpend(tx: Tx | ProcessedTx): Promise<boolean> {
-    // We only consider non-empty nullifiers
-    const newNullifiers = [
-      ...tx.data.endNonRevertibleData.newNullifiers.filter(n => !n.isEmpty()),
-      ...tx.data.end.newNullifiers.filter(n => !n.isEmpty()),
-    ];
-
-    // Ditch this tx if it has a repeated nullifiers
-    const uniqNullifiers = new Set(newNullifiers.map(n => n.value.toBigInt()));
-    if (uniqNullifiers.size !== newNullifiers.length) {
-      return true;
-    }
-
-    for (const nullifier of newNullifiers) {
-      // TODO(AD): this is an exhaustive search currently
-      const db = this.worldState.getLatest();
-      const indexInDb = await db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-      if (indexInDb !== undefined) {
-        return true;
-      }
-    }
-    return false;
+    const [block] = await this.blockBuilder.buildL2Block(globalVariables, allTxs, l1ToL2Messages);
+    return block;
   }
 
   get coinbase(): EthAddress {

package/src/sequencer/tx_validator.ts

@@ -0,0 +1,189 @@
+import { Tx } from '@aztec/circuit-types';
+import { AztecAddress, EthAddress, Fr, GlobalVariables } from '@aztec/circuits.js';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { Logger, createDebugLogger } from '@aztec/foundation/log';
+import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { ProcessedTx } from './processed_tx.js';
+
+/** A source of what nullifiers have been committed to the state trees */
+export interface NullifierSource {
+  getNullifierIndex: (nullifier: Fr) => Promise<bigint | undefined>;
+}
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}
+
+// prefer symbols over booleans so it's clear what the intention is
+// vs returning true/false is tied to the function name
+// eg. isDoubleSpend vs isValidChain assign different meanings to booleans
+const VALID_TX = Symbol('valid_tx');
+const INVALID_TX = Symbol('invalid_tx');
+
+type TxValidationStatus = typeof VALID_TX | typeof INVALID_TX;
+
+// the storage slot associated with "storage.balances"
+const GAS_TOKEN_BALANCES_SLOT = new Fr(1);
+
+export class TxValidator {
+  #log: Logger;
+  #globalVariables: GlobalVariables;
+  #nullifierSource: NullifierSource;
+  #publicStateSource: PublicStateSource;
+  #gasPortalAddress: EthAddress;
+
+  constructor(
+    nullifierSource: NullifierSource,
+    publicStateSource: PublicStateSource,
+    gasPortalAddress: EthAddress,
+    globalVariables: GlobalVariables,
+    log = createDebugLogger('aztec:sequencer:tx_validator'),
+  ) {
+    this.#nullifierSource = nullifierSource;
+    this.#globalVariables = globalVariables;
+    this.#publicStateSource = publicStateSource;
+    this.#gasPortalAddress = gasPortalAddress;
+
+    this.#log = log;
+  }
+
+  /**
+   * Validates a list of transactions.
+   * @param txs - The transactions to validate.
+   * @returns A tuple of valid and invalid transactions.
+   */
+  public async validateTxs<T extends Tx | ProcessedTx>(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    const thisBlockNullifiers = new Set<bigint>();
+
+    for (const tx of txs) {
+      if (this.#validateMetadata(tx) === INVALID_TX) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      if ((await this.#validateNullifiers(tx, thisBlockNullifiers)) === INVALID_TX) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      // skip already processed transactions
+      if (tx instanceof Tx && (await this.#validateFee(tx)) === INVALID_TX) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  /**
+   * It rejects transactions with the wrong chain id.
+   * @param tx - The transaction.
+   * @returns Whether the transaction is valid.
+   */
+  #validateMetadata(tx: Tx | ProcessedTx): TxValidationStatus {
+    if (!tx.data.constants.txContext.chainId.equals(this.#globalVariables.chainId)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toString()} != ${this.#globalVariables.chainId.toString()}`,
+      );
+      return INVALID_TX;
+    }
+
+    return VALID_TX;
+  }
+
+  /**
+   * It looks for duplicate nullifiers:
+   * - in the same transaction
+   * - in the same block
+   * - in the nullifier tree
+   *
+   * Nullifiers prevent double spends in a private context.
+   *
+   * @param tx - The transaction.
+   * @returns Whether this is a problematic double spend that the L1 contract would reject.
+   */
+  async #validateNullifiers(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): Promise<TxValidationStatus> {
+    const newNullifiers = [...tx.data.endNonRevertibleData.newNullifiers, ...tx.data.end.newNullifiers]
+      .filter(x => !x.isEmpty())
+      .map(x => x.value.toBigInt());
+
+    // Ditch this tx if it has repeated nullifiers
+    const uniqueNullifiers = new Set(newNullifiers);
+    if (uniqueNullifiers.size !== newNullifiers.length) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      return INVALID_TX;
+    }
+
+    for (const nullifier of newNullifiers) {
+      if (thisBlockNullifiers.has(nullifier)) {
+        this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier in the same block`);
+        return INVALID_TX;
+      }
+
+      thisBlockNullifiers.add(nullifier);
+    }
+
+    const nullifierIndexes = await Promise.all(
+      newNullifiers.map(n => this.#nullifierSource.getNullifierIndex(new Fr(n))),
+    );
+
+    const hasDuplicates = nullifierIndexes.some(index => index !== undefined);
+    if (hasDuplicates) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating nullifiers present in state trees`);
+      return INVALID_TX;
+    }
+
+    return VALID_TX;
+  }
+
+  async #validateFee(tx: Tx): Promise<TxValidationStatus> {
+    if (!tx.data.needsTeardown) {
+      // TODO check if fees are mandatory and reject this tx
+      this.#log.debug(`Tx ${Tx.getHash(tx)} doesn't pay for gas`);
+      return VALID_TX;
+    }
+
+    const {
+      // TODO what if there's more than one function call?
+      // if we're to enshrine that teardown = 1 function call, then we should turn this into a single function call
+      [PublicKernelPhase.TEARDOWN]: [teardownFn],
+    } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls);
+
+    if (!teardownFn) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(tx)} because it should pay for gas but has no enqueued teardown function call`,
+      );
+      return INVALID_TX;
+    }
+
+    // TODO(#1204) if a generator index is used for the derived storage slot of a map, update it here as well
+    const slot = pedersenHash([GAS_TOKEN_BALANCES_SLOT.toBuffer(), teardownFn.callContext.msgSender.toBuffer()]);
+    const gasBalance = await this.#publicStateSource.storageRead(
+      getCanonicalGasTokenAddress(this.#gasPortalAddress),
+      slot,
+    );
+
+    // TODO(#5004) calculate fee needed based on tx limits and gas prices
+    const gasAmountNeeded = new Fr(1);
+    if (gasBalance.lt(gasAmountNeeded)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because it should pay for gas but has insufficient balance ${gasBalance.toShortString()} < ${gasAmountNeeded.toShortString()}`,
+      );
+      return INVALID_TX;
+    }
+
+    return VALID_TX;
+  }
+}

package/src/simulator/public_executor.ts

@@ -1,6 +1,4 @@
 import {
-  ContractDataSource,
-  ExtendedContractData,
   L1ToL2MessageSource,
   MerkleTreeId,
   NullifierMembershipWitness,
@@ -22,9 +20,8 @@ import {
 import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import { InstanceDeployerAddress } from '@aztec/protocol-contracts/instance-deployer';
 import { CommitmentsDB, MessageLoadOracleInputs, PublicContractsDB, PublicStateDB } from '@aztec/simulator';
-import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 /**
@@ -32,7 +29,6 @@ import { MerkleTreeOperations } from '@aztec/world-state';
  * Progressively records contracts in transaction as they are processed in a block.
  */
 export class ContractsDataSourcePublicDB implements PublicContractsDB {
-  private cache = new Map<string, ExtendedContractData>();
   private instanceCache = new Map<string, ContractInstanceWithAddress>();
   private classCache = new Map<string, ContractClassPublic>();
 
@@ -51,7 +47,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
       this.log(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
     });
-    ContractInstanceDeployedEvent.fromLogs(logs, InstanceDeployerAddress).forEach(e => {
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
       this.log(
         `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
       );
@@ -73,9 +69,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e =>
       this.classCache.delete(e.contractClassId.toString()),
     );
-    ContractInstanceDeployedEvent.fromLogs(logs, InstanceDeployerAddress).forEach(e =>
-      this.instanceCache.delete(e.address.toString()),
-    );
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
     return Promise.resolve();
   }
 
@@ -83,46 +77,25 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
   }
 
-  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.getPublicFunction(selector)?.bytecode;
+  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
+    return this.classCache.get(contractClassId.toString()) ?? (await this.db.getContractClass(contractClassId));
   }
 
-  async getIsInternal(address: AztecAddress, selector: FunctionSelector): Promise<boolean | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.getPublicFunction(selector)?.isInternal;
-  }
-
-  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    const contract = await this.#getContract(address);
-    return contract?.contractData.portalContractAddress;
-  }
-
-  async #getContract(address: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return (
-      this.cache.get(address.toString()) ??
-      (await this.#makeExtendedContractDataFor(address)) ??
-      (await this.db.getExtendedContractData(address))
-    );
-  }
-
-  async #makeExtendedContractDataFor(address: AztecAddress): Promise<ExtendedContractData | undefined> {
-    const instance = this.instanceCache.get(address.toString());
+  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    const instance = await this.getContractInstance(address);
     if (!instance) {
-      return undefined;
+      throw new Error(`Contract ${address.toString()} not found`);
     }
-
-    const contractClass =
-      this.classCache.get(instance.contractClassId.toString()) ??
-      (await this.db.getContractClass(instance.contractClassId));
+    const contractClass = await this.getContractClass(instance.contractClassId);
     if (!contractClass) {
-      this.log.warn(
-        `Contract class ${instance.contractClassId.toString()} for address ${address.toString()} not found`,
-      );
-      return undefined;
+      throw new Error(`Contract class ${instance.contractClassId.toString()} for ${address.toString()} not found`);
     }
+    return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
+  }
 
-    return ExtendedContractData.fromClassAndInstance(contractClass, instance);
+  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
+    const contract = await this.getContractInstance(address);
+    return contract?.portalContractAddress;
   }
 }