@aztec/sequencer-client 0.34.0 → 0.35.0

package/src/sequencer/tx_validator.ts

@@ -1,265 +0,0 @@
-import { type ProcessedTx, Tx } from '@aztec/circuit-types';
-import {
-  type AztecAddress,
-  type EthAddress,
-  Fr,
-  type GlobalVariables,
-  type PublicCallRequest,
-} from '@aztec/circuits.js';
-import { pedersenHash } from '@aztec/foundation/crypto';
-import { type Logger, createDebugLogger } from '@aztec/foundation/log';
-import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
-import { type ContractDataSource } from '@aztec/types/contracts';
-
-import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.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);
-
-type FeeValidationConfig = {
-  gasPortalAddress: EthAddress;
-  allowedFeePaymentContractClasses: Fr[];
-  allowedFeePaymentContractInstances: AztecAddress[];
-};
-
-export class TxValidator {
-  #log: Logger;
-  #globalVariables: GlobalVariables;
-  #nullifierSource: NullifierSource;
-  #publicStateSource: PublicStateSource;
-  #contractDataSource: ContractDataSource;
-  #feeValidationConfig: FeeValidationConfig;
-
-  constructor(
-    nullifierSource: NullifierSource,
-    publicStateSource: PublicStateSource,
-    contractDataSource: ContractDataSource,
-    globalVariables: GlobalVariables,
-    feeValidationConfig: FeeValidationConfig,
-    log = createDebugLogger('aztec:sequencer:tx_validator'),
-  ) {
-    this.#nullifierSource = nullifierSource;
-    this.#publicStateSource = publicStateSource;
-    this.#contractDataSource = contractDataSource;
-    this.#globalVariables = globalVariables;
-    this.#feeValidationConfig = feeValidationConfig;
-    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) {
-        if ((await this.#validateFee(tx)) === INVALID_TX) {
-          invalidTxs.push(tx);
-          continue;
-        }
-        if ((await this.#validateGasBalance(tx)) === INVALID_TX) {
-          invalidTxs.push(tx);
-          continue;
-        }
-      }
-
-      if (this.#validateMaxBlockNumber(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.getNonEmptyNullifiers().map(x => x.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 #validateGasBalance(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.forPublic || !tx.data.forPublic.needsTeardown) {
-      return VALID_TX;
-    }
-
-    const teardownFn = TxValidator.#extractFeeExecutionCall(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, teardownFn.callContext.msgSender]);
-    const gasBalance = await this.#publicStateSource.storageRead(
-      getCanonicalGasTokenAddress(this.#feeValidationConfig.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;
-  }
-
-  #validateMaxBlockNumber(tx: Tx | ProcessedTx): TxValidationStatus {
-    const target =
-      tx instanceof Tx
-        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
-        : tx.data.rollupValidationRequests;
-    const maxBlockNumber = target.maxBlockNumber;
-
-    if (maxBlockNumber.isSome && maxBlockNumber.value < this.#globalVariables.blockNumber) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for low max block number`);
-      return INVALID_TX;
-    } else {
-      return VALID_TX;
-    }
-  }
-
-  async #validateFee(tx: Tx): Promise<TxValidationStatus> {
-    if (!tx.data.forPublic || !tx.data.forPublic.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 teardownFn = TxValidator.#extractFeeExecutionCall(tx);
-    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;
-    }
-
-    const fpcAddress = teardownFn.contractAddress;
-    const contractClass = await this.#contractDataSource.getContract(fpcAddress);
-
-    if (!contractClass) {
-      return INVALID_TX;
-    }
-
-    if (fpcAddress.equals(getCanonicalGasTokenAddress(this.#feeValidationConfig.gasPortalAddress))) {
-      return VALID_TX;
-    }
-
-    for (const allowedContract of this.#feeValidationConfig.allowedFeePaymentContractInstances) {
-      if (fpcAddress.equals(allowedContract)) {
-        return VALID_TX;
-      }
-    }
-
-    for (const allowedContractClass of this.#feeValidationConfig.allowedFeePaymentContractClasses) {
-      if (contractClass.contractClassId.equals(allowedContractClass)) {
-        return VALID_TX;
-      }
-    }
-
-    return INVALID_TX;
-  }
-
-  static #extractFeeExecutionCall(tx: Tx): PublicCallRequest | undefined {
-    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);
-
-    return teardownFn;
-  }
-}

package/src/sequencer/tx_validator_factory.ts

@@ -1,32 +0,0 @@
-import { type AztecAddress, type EthAddress, type Fr, type GlobalVariables } from '@aztec/circuits.js';
-import { type ContractDataSource } from '@aztec/types/contracts';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
-import { TxValidator } from './tx_validator.js';
-
-export class TxValidatorFactory {
-  constructor(
-    private merkleTreeDb: MerkleTreeOperations,
-    private contractDataSource: ContractDataSource,
-    private gasPortalAddress: EthAddress,
-  ) {}
-
-  buildTxValidator(
-    globalVariables: GlobalVariables,
-    allowedFeePaymentContractClasses: Fr[],
-    allowedFeePaymentContractInstances: AztecAddress[],
-  ): TxValidator {
-    return new TxValidator(
-      new WorldStateDB(this.merkleTreeDb),
-      new WorldStatePublicDB(this.merkleTreeDb),
-      this.contractDataSource,
-      globalVariables,
-      {
-        allowedFeePaymentContractClasses,
-        allowedFeePaymentContractInstances,
-        gasPortalAddress: this.gasPortalAddress,
-      },
-    );
-  }
-}

package/src/sequencer/utils.ts

@@ -1,31 +0,0 @@
-import { type Tx } from '@aztec/circuit-types';
-import { CallRequest } from '@aztec/circuits.js';
-
-/**
- * Looks at the side effects of a transaction and returns the highest counter
- * @param tx - A transaction
- * @returns The highest side effect counter in the transaction so far
- */
-export function lastSideEffectCounter(tx: Tx): number {
-  const data = tx.data.forPublic!;
-  const sideEffectCounters = [
-    ...data.endNonRevertibleData.newNoteHashes,
-    ...data.endNonRevertibleData.newNullifiers,
-    ...data.endNonRevertibleData.publicCallStack,
-    ...data.end.newNoteHashes,
-    ...data.end.newNullifiers,
-    ...data.end.publicCallStack,
-  ];
-
-  let max = 0;
-  for (const sideEffect of sideEffectCounters) {
-    if (sideEffect instanceof CallRequest) {
-      // look at both start and end counters because for enqueued public calls start > 0 while end === 0
-      max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
-    } else {
-      max = Math.max(max, sideEffect.counter.toNumber());
-    }
-  }
-
-  return max;
-}

package/src/simulator/index.ts

@@ -1,36 +0,0 @@
-import {
-  type KernelCircuitPublicInputs,
-  type PublicKernelCircuitPrivateInputs,
-  type PublicKernelCircuitPublicInputs,
-  type PublicKernelTailCircuitPrivateInputs,
-} from '@aztec/circuits.js';
-
-/**
- * Circuit simulator for the public kernel circuits.
- */
-export interface PublicKernelCircuitSimulator {
-  /**
-   * Simulates the public kernel setup circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  publicKernelCircuitSetup(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
-  /**
-   * Simulates the public kernel app logic circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  publicKernelCircuitAppLogic(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
-  /**
-   * Simulates the public kernel teardown circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
-  /**
-   * Simulates the public kernel tail circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<KernelCircuitPublicInputs>;
-}

package/src/simulator/public_executor.ts

@@ -1,267 +0,0 @@
-import { MerkleTreeId, NullifierMembershipWitness, type Tx } from '@aztec/circuit-types';
-import {
-  type AztecAddress,
-  ContractClassRegisteredEvent,
-  ContractInstanceDeployedEvent,
-  type EthAddress,
-  Fr,
-  type FunctionSelector,
-  type L1_TO_L2_MSG_TREE_HEIGHT,
-  type NULLIFIER_TREE_HEIGHT,
-  type NullifierLeafPreimage,
-  type PublicDataTreeLeafPreimage,
-} from '@aztec/circuits.js';
-import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import {
-  type CommitmentsDB,
-  MessageLoadOracleInputs,
-  type PublicContractsDB,
-  type PublicStateDB,
-} from '@aztec/simulator';
-import {
-  type ContractClassPublic,
-  type ContractDataSource,
-  type ContractInstanceWithAddress,
-} from '@aztec/types/contracts';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-/**
- * Implements the PublicContractsDB using a ContractDataSource.
- * Progressively records contracts in transaction as they are processed in a block.
- */
-export class ContractsDataSourcePublicDB implements PublicContractsDB {
-  private instanceCache = new Map<string, ContractInstanceWithAddress>();
-  private classCache = new Map<string, ContractClassPublic>();
-
-  private log = createDebugLogger('aztec:sequencer:contracts-data-source');
-
-  constructor(private db: ContractDataSource) {}
-
-  /**
-   * Add new contracts from a transaction
-   * @param tx - The transaction to add contracts from.
-   */
-  public addNewContracts(tx: Tx): Promise<void> {
-    // Extract contract class and instance data from logs and add to cache for this block
-    const logs = tx.unencryptedLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e => {
-      this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
-      this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
-    });
-    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
-      this.log.debug(
-        `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
-      );
-      this.instanceCache.set(e.address.toString(), e.toContractInstance());
-    });
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Removes new contracts added from transactions
-   * @param tx - The tx's contracts to be removed
-   */
-  public removeNewContracts(tx: Tx): Promise<void> {
-    // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
-    // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
-    // wouldn't that accidentally remove the contract added on the first one?
-    const logs = tx.unencryptedLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e =>
-      this.classCache.delete(e.contractClassId.toString()),
-    );
-    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
-    return Promise.resolve();
-  }
-
-  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
-  }
-
-  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
-    return this.classCache.get(contractClassId.toString()) ?? (await this.db.getContractClass(contractClassId));
-  }
-
-  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    const instance = await this.getContractInstance(address);
-    if (!instance) {
-      throw new Error(`Contract ${address.toString()} not found`);
-    }
-    const contractClass = await this.getContractClass(instance.contractClassId);
-    if (!contractClass) {
-      throw new Error(`Contract class ${instance.contractClassId.toString()} for ${address.toString()} not found`);
-    }
-    return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
-  }
-
-  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    const contract = await this.getContractInstance(address);
-    return contract?.portalContractAddress;
-  }
-}
-
-/**
- * Implements the PublicStateDB using a world-state database.
- */
-export class WorldStatePublicDB implements PublicStateDB {
-  private committedWriteCache: Map<bigint, Fr> = new Map();
-  private checkpointedWriteCache: Map<bigint, Fr> = new Map();
-  private uncommittedWriteCache: Map<bigint, Fr> = new Map();
-
-  constructor(private db: MerkleTreeOperations) {}
-
-  /**
-   * Reads a value from public storage, returning zero if none.
-   * @param contract - Owner of the storage.
-   * @param slot - Slot to read in the contract storage.
-   * @returns The current value in the storage slot.
-   */
-  public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
-    const leafSlot = computePublicDataTreeLeafSlot(contract, slot).value;
-    const uncommitted = this.uncommittedWriteCache.get(leafSlot);
-    if (uncommitted !== undefined) {
-      return uncommitted;
-    }
-    const checkpointed = this.checkpointedWriteCache.get(leafSlot);
-    if (checkpointed !== undefined) {
-      return checkpointed;
-    }
-    const committed = this.committedWriteCache.get(leafSlot);
-    if (committed !== undefined) {
-      return committed;
-    }
-
-    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
-      return Fr.ZERO;
-    }
-
-    const preimage = (await this.db.getLeafPreimage(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      lowLeafResult.index,
-    )) as PublicDataTreeLeafPreimage;
-
-    return preimage.value;
-  }
-
-  /**
-   * Records a write to public storage.
-   * @param contract - Owner of the storage.
-   * @param slot - Slot to read in the contract storage.
-   * @param newValue - The new value to store.
-   */
-  public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
-    const index = computePublicDataTreeLeafSlot(contract, slot).value;
-    this.uncommittedWriteCache.set(index, newValue);
-    return Promise.resolve();
-  }
-
-  /**
-   * Commit the pending changes to the DB.
-   * @returns Nothing.
-   */
-  commit(): Promise<void> {
-    for (const [k, v] of this.checkpointedWriteCache) {
-      this.committedWriteCache.set(k, v);
-    }
-    // uncommitted writes take precedence over checkpointed writes
-    // since they are the most recent
-    for (const [k, v] of this.uncommittedWriteCache) {
-      this.committedWriteCache.set(k, v);
-    }
-    return this.rollbackToCommit();
-  }
-
-  /**
-   * Rollback the pending changes.
-   * @returns Nothing.
-   */
-  async rollbackToCommit(): Promise<void> {
-    await this.rollbackToCheckpoint();
-    this.checkpointedWriteCache = new Map<bigint, Fr>();
-    return Promise.resolve();
-  }
-
-  checkpoint(): Promise<void> {
-    for (const [k, v] of this.uncommittedWriteCache) {
-      this.checkpointedWriteCache.set(k, v);
-    }
-    return this.rollbackToCheckpoint();
-  }
-
-  rollbackToCheckpoint(): Promise<void> {
-    this.uncommittedWriteCache = new Map<bigint, Fr>();
-    return Promise.resolve();
-  }
-}
-
-/**
- * Implements WorldState db using a world state database.
- */
-export class WorldStateDB implements CommitmentsDB {
-  constructor(private db: MerkleTreeOperations) {}
-
-  public async getNullifierMembershipWitnessAtLatestBlock(
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-    if (!index) {
-      return undefined;
-    }
-
-    const leafPreimagePromise = this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-    const siblingPathPromise = this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
-      MerkleTreeId.NULLIFIER_TREE,
-      BigInt(index),
-    );
-
-    const [leafPreimage, siblingPath] = await Promise.all([leafPreimagePromise, siblingPathPromise]);
-
-    if (!leafPreimage) {
-      return undefined;
-    }
-
-    return new NullifierMembershipWitness(BigInt(index), leafPreimage as NullifierLeafPreimage, siblingPath);
-  }
-
-  public async getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    let nullifierIndex: bigint | undefined;
-    let messageIndex: bigint | undefined;
-    let startIndex = 0n;
-
-    // We iterate over messages until we find one whose nullifier is not in the nullifier tree --> we need to check
-    // for nullifiers because messages can have duplicates.
-    do {
-      messageIndex = (await this.db.findLeafIndexAfter(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash, startIndex))!;
-      if (messageIndex === undefined) {
-        throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
-      }
-
-      const messageNullifier = computeL1ToL2MessageNullifier(contractAddress, messageHash, secret, messageIndex);
-      nullifierIndex = await this.getNullifierIndex(messageNullifier);
-
-      startIndex = messageIndex + 1n;
-    } while (nullifierIndex !== undefined);
-
-    const siblingPath = await this.db.getSiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>(
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      messageIndex,
-    );
-
-    return new MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>(messageIndex, siblingPath);
-  }
-
-  public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
-    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
-  }
-
-  public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
-    return await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-  }
-}