@aztec/pxe 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

package/src/contract_function_simulator/proxied_contract_data_source.ts

@@ -1,83 +0,0 @@
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractOverrides } from '@aztec/stdlib/tx';
-
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-
-/*
- * Proxy generator for a ContractStore that allows overriding contract instances and artifacts, so
- * the contract function simulator can execute different bytecode on certain addresses. An example use case
- * would be overriding your own account contract so that valid signatures don't have to be provided while simulating.
- */
-export class ProxiedContractStoreFactory {
-  static create(contractStore: ContractStore, overrides?: ContractOverrides) {
-    if (!overrides) {
-      return contractStore;
-    }
-
-    return new Proxy(contractStore, {
-      get(target, prop: keyof ContractStore) {
-        switch (prop) {
-          case 'getContractInstance': {
-            return async (address: AztecAddress) => {
-              if (overrides[address.toString()]) {
-                const { instance } = overrides[address.toString()]!;
-                instance.address = address;
-                const realInstance = await target.getContractInstance(address);
-                if (!realInstance) {
-                  throw new Error(`Contract instance not found for address: ${address}`);
-                }
-                instance.currentContractClassId = realInstance.currentContractClassId;
-                instance.originalContractClassId = realInstance.originalContractClassId;
-                return instance;
-              } else {
-                return target.getContractInstance(address);
-              }
-            };
-          }
-          case 'getFunctionArtifact': {
-            return async (contractAddress: AztecAddress, selector: FunctionSelector) => {
-              if (overrides[contractAddress.toString()]) {
-                const { artifact } = overrides[contractAddress.toString()]!;
-                const functions = artifact.functions;
-                for (let i = 0; i < functions.length; i++) {
-                  const fn = functions[i];
-                  const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
-                  if (fnSelector.equals(selector)) {
-                    return fn;
-                  }
-                }
-              } else {
-                return target.getFunctionArtifact(contractAddress, selector);
-              }
-            };
-          }
-          case 'getFunctionArtifactWithDebugMetadata': {
-            return async (contractAddress: AztecAddress, selector: FunctionSelector) => {
-              if (overrides[contractAddress.toString()]) {
-                const { artifact } = overrides[contractAddress.toString()]!;
-                const functions = artifact.functions;
-                for (let i = 0; i < functions.length; i++) {
-                  const fn = functions[i];
-                  const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
-                  if (fnSelector.equals(selector)) {
-                    return fn;
-                  }
-                }
-              } else {
-                return target.getFunctionArtifactWithDebugMetadata(contractAddress, selector);
-              }
-            };
-          }
-          default: {
-            const value = Reflect.get(target, prop);
-            if (typeof value === 'function') {
-              return value.bind(target);
-            }
-            return value;
-          }
-        }
-      },
-    });
-  }
-}

package/src/contract_sync/contract_sync_service.ts

@@ -1,152 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-
-import type { AccessScopes } from '../access_scopes.js';
-import type { StagedStore } from '../job_coordinator/job_coordinator.js';
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-import type { NoteStore } from '../storage/note_store/note_store.js';
-import { syncState, verifyCurrentClassId } from './helpers.js';
-
-/**
- * Service for syncing the private state of contracts and verifying that the PXE holds the current class artifact.
- * It uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
- *
- * TODO: The StagedStore naming is broken here. Figure out a better name.
- */
-export class ContractSyncService implements StagedStore {
-  readonly storeName = 'contract_sync';
-
-  // Tracks contracts synced since last wipe. The cache is keyed per individual scope address
-  // (`contractAddress:scopeAddress`), or `contractAddress:*` for undefined scopes (all accounts).
-  // The value is a promise that resolves when the contract is synced.
-  private syncedContracts: Map<string, Promise<void>> = new Map();
-
-  // Per-job overridden contract addresses - these contracts should not be synced.
-  private overriddenContracts: Map<string, Set<string>> = new Map();
-
-  constructor(
-    private aztecNode: AztecNode,
-    private contractStore: ContractStore,
-    private noteStore: NoteStore,
-    private log: Logger,
-  ) {}
-
-  /** Sets contracts that should be skipped during sync for a specific job. */
-  setOverriddenContracts(jobId: string, addresses: Set<string>): void {
-    this.overriddenContracts.set(jobId, addresses);
-  }
-
-  /**
-   * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
-   * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
-   * @param contractAddress - The address of the contract to sync.
-   * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
-   * not sync_state itself).
-   * @param utilityExecutor - Executor function for running the sync_state utility function.
-   * @param scopes - Access scopes to pass through to the utility executor (affects whose account's private state is discovered).
-   */
-  async ensureContractSynced(
-    contractAddress: AztecAddress,
-    functionToInvokeAfterSync: FunctionSelector | null,
-    utilityExecutor: (call: FunctionCall, scopes: AccessScopes) => Promise<any>,
-    anchorBlockHeader: BlockHeader,
-    jobId: string,
-    scopes: AccessScopes,
-  ): Promise<void> {
-    // Skip sync if this contract has an override for this job (overrides are keyed by contract address only)
-    const overrides = this.overriddenContracts.get(jobId);
-    if (overrides?.has(contractAddress.toString())) {
-      return;
-    }
-
-    // Skip sync if we already synced for "all scopes", or if we have an empty list of scopes
-    const allScopesKey = toKey(contractAddress, 'ALL_SCOPES');
-    const allScopesExisting = this.syncedContracts.get(allScopesKey);
-    if (allScopesExisting || (scopes !== 'ALL_SCOPES' && scopes.length == 0)) {
-      return;
-    }
-
-    const unsyncedScopes =
-      scopes === 'ALL_SCOPES'
-        ? scopes
-        : scopes.filter(scope => !this.syncedContracts.has(toKey(contractAddress, scope)));
-    const unsyncedScopesKeys = toKeys(contractAddress, unsyncedScopes);
-
-    if (unsyncedScopesKeys.length > 0) {
-      // Start sync and store the promise for all unsynced scopes
-      const promise = this.#doSync(
-        contractAddress,
-        functionToInvokeAfterSync,
-        utilityExecutor,
-        anchorBlockHeader,
-        jobId,
-        unsyncedScopes,
-      ).catch(err => {
-        // There was an error syncing the contract, so we remove it from the cache so that it can be retried.
-        unsyncedScopesKeys.forEach(key => this.syncedContracts.delete(key));
-        throw err;
-      });
-      unsyncedScopesKeys.forEach(key => this.syncedContracts.set(key, promise));
-    }
-
-    const promises = toKeys(contractAddress, scopes).map(key => this.syncedContracts.get(key)!);
-    await Promise.all(promises);
-  }
-
-  async #doSync(
-    contractAddress: AztecAddress,
-    functionToInvokeAfterSync: FunctionSelector | null,
-    utilityExecutor: (call: FunctionCall, scopes: AccessScopes) => Promise<any>,
-    anchorBlockHeader: BlockHeader,
-    jobId: string,
-    scopes: AccessScopes,
-  ): Promise<void> {
-    this.log.debug(`Syncing contract ${contractAddress}`);
-    await Promise.all([
-      syncState(
-        contractAddress,
-        this.contractStore,
-        functionToInvokeAfterSync,
-        utilityExecutor,
-        this.noteStore,
-        this.aztecNode,
-        anchorBlockHeader,
-        jobId,
-        scopes,
-      ),
-      verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader),
-    ]);
-    this.log.debug(`Contract ${contractAddress} synced`);
-  }
-
-  /** Clears sync cache. Called by BlockSynchronizer when anchor block changes. */
-  wipe(): void {
-    this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
-    this.syncedContracts.clear();
-  }
-
-  commit(jobId: string): Promise<void> {
-    // Clear overridden contracts for this job
-    this.overriddenContracts.delete(jobId);
-    return Promise.resolve();
-  }
-
-  discardStaged(jobId: string): Promise<void> {
-    // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
-    // the sync are also undone.
-    this.syncedContracts.clear();
-    this.overriddenContracts.delete(jobId);
-    return Promise.resolve();
-  }
-}
-
-function toKeys(contract: AztecAddress, scopes: AccessScopes) {
-  return scopes === 'ALL_SCOPES' ? [toKey(contract, scopes)] : scopes.map(scope => toKey(contract, scope));
-}
-
-function toKey(contract: AztecAddress, scope: AztecAddress | 'ALL_SCOPES') {
-  return scope === 'ALL_SCOPES' ? `${contract.toString()}:*` : `${contract.toString()}:${scope.toString()}`;
-}

package/src/contract_sync/helpers.ts

@@ -1,98 +0,0 @@
-import { ProtocolContractAddress, isProtocolContract } from '@aztec/protocol-contracts';
-import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstance } from '@aztec/stdlib/contract';
-import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-
-import type { AccessScopes } from '../access_scopes.js';
-import { NoteService } from '../notes/note_service.js';
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-import type { NoteStore } from '../storage/note_store/note_store.js';
-
-/**
- * Read the current class id of a contract from the execution data provider or AztecNode. If not found, class id
- * from the instance is used.
- * @param contractAddress - The address of the contract to read the class id for.
- * @param instance - The instance of the contract.
- * @param aztecNode - The Aztec node to query for storage.
- * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
- * @returns The current class id.
- */
-export async function readCurrentClassId(
-  contractAddress: AztecAddress,
-  instance: ContractInstance,
-  aztecNode: AztecNode,
-  header: BlockHeader,
-) {
-  const blockHash = await header.hash();
-  const timestamp = header.globalVariables.timestamp;
-  const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-  const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
-    aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot),
-  );
-  let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
-  if (currentClassId.isZero()) {
-    currentClassId = instance.originalContractClassId;
-  }
-  return currentClassId;
-}
-
-export async function syncState(
-  contractAddress: AztecAddress,
-  contractStore: ContractStore,
-  functionToInvokeAfterSync: FunctionSelector | null,
-  utilityExecutor: (privateSyncCall: FunctionCall, scopes: AccessScopes) => Promise<any>,
-  noteStore: NoteStore,
-  aztecNode: AztecNode,
-  anchorBlockHeader: BlockHeader,
-  jobId: string,
-  scopes: AccessScopes,
-) {
-  // Protocol contracts don't have private state to sync
-  if (!isProtocolContract(contractAddress)) {
-    const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [], contractAddress);
-    if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
-      throw new Error(
-        'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
-      );
-    }
-
-    const noteService = new NoteService(noteStore, aztecNode, anchorBlockHeader, jobId);
-
-    // Both sync_state and syncNoteNullifiers interact with the note store, but running them in parallel is safe
-    // because note store is designed to handle concurrent operations.
-    await Promise.all([
-      utilityExecutor(syncStateFunctionCall, scopes),
-      noteService.syncNoteNullifiers(contractAddress, scopes),
-    ]);
-  }
-}
-
-/**
- * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
- * provider (i.e. PXE's own storage).
- * @param contractAddress - The address of the contract to verify.
- * @param aztecNode - The Aztec node to query for storage.
- * @param contractStore - The contract store to fetch the local instance from.
- * @param header - The header of the block at which to verify the current class id.
- */
-export async function verifyCurrentClassId(
-  contractAddress: AztecAddress,
-  aztecNode: AztecNode,
-  contractStore: ContractStore,
-  header: BlockHeader,
-) {
-  const instance = await contractStore.getContractInstance(contractAddress);
-  if (!instance) {
-    throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
-  }
-
-  const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
-  if (!instance.currentContractClassId.equals(currentClassId)) {
-    throw new Error(
-      `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,
-    );
-  }
-}

package/src/storage/tagging_store/sender_address_book_store.ts

@@ -1,48 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-/**
- * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
- * to derive directional app tagging secrets that are then used to sync the logs.
- */
-export class SenderAddressBookStore {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-  }
-
-  addSender(address: AztecAddress): Promise<boolean> {
-    return this.#store.transactionAsync(async () => {
-      if (await this.#addressBook.hasAsync(address.toString())) {
-        return false;
-      }
-
-      await this.#addressBook.set(address.toString(), true);
-
-      return true;
-    });
-  }
-
-  getSenders(): Promise<AztecAddress[]> {
-    return this.#store.transactionAsync(async () => {
-      return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-    });
-  }
-
-  removeSender(address: AztecAddress): Promise<boolean> {
-    return this.#store.transactionAsync(async () => {
-      if (!(await this.#addressBook.hasAsync(address.toString()))) {
-        return false;
-      }
-
-      await this.#addressBook.delete(address.toString());
-
-      return true;
-    });
-  }
-}

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,140 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { BlockHash } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { ExtendedDirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
-
-import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { findHighestIndexes } from './utils/find_highest_indexes.js';
-import { loadLogsForRange } from './utils/load_logs_for_range.js';
-
-/**
- * Loads private logs for the app-sender-recipient triplet defined by `secret` and updates the highest aged and
- * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
- *
- * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
- * in the tagging data provider is indexed by the secret and hence completely disjoint.
- */
-export async function loadPrivateLogsForSenderRecipientPair(
-  secret: ExtendedDirectionalAppTaggingSecret,
-  aztecNode: AztecNode,
-  taggingStore: RecipientTaggingStore,
-  anchorBlockNumber: BlockNumber,
-  anchorBlockHash: BlockHash,
-  jobId: string,
-): Promise<TxScopedL2Log[]> {
-  // # Explanation of how the algorithm works
-  // When we perform the sync we will look at logs that correspond to the tagging index range
-  // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
-  //
-  // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
-  //                  `MAX_TX_LIFETIME` seconds ago.
-  // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
-  //
-  // "(" denotes an open end of the range - the index is not included in the range.
-  // "]" denotes a closed end of the range - the index is included in the range.
-  //
-  // ## Explanation of highestAgedIndex
-  //
-  // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
-  // ever appear.
-  //
-  // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
-  // - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` seconds after
-  //   the timestamp of its anchor block; and
-  // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
-  //
-  // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
-  // least `MAX_TX_LIFETIME` seconds in the past. Then there is no possibility of any *other* device
-  // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
-  // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
-  // chosen a larger index.
-  //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
-  // because it would already have been expired.
-  //
-  // Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
-  // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
-  //
-  // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
-  //
-  // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
-  // the highest finalized index. If that index was already used, they will throw an error. For this reason we
-  // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
-
-  let finalizedBlockNumber: number, currentTimestamp: bigint;
-  {
-    const [l2Tips, latestBlockHeader] = await Promise.all([aztecNode.getL2Tips(), aztecNode.getBlockHeader('latest')]);
-
-    if (!latestBlockHeader) {
-      throw new Error('Node failed to return latest block header when syncing logs');
-    }
-
-    [finalizedBlockNumber, currentTimestamp] = [
-      l2Tips.finalized.block.number,
-      latestBlockHeader.globalVariables.timestamp,
-    ];
-  }
-
-  let start: number, end: number;
-  {
-    const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
-    const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-
-    // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
-    start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
-
-    // The highest index a sender can choose is "highest finalized index + window length" but given that
-    // `loadLogsForRange` expects an exclusive `end` we add 1.
-    end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
-  }
-
-  const logs: TxScopedL2Log[] = [];
-
-  while (true) {
-    // Get private logs with their block timestamps and corresponding tagging indexes
-    const privateLogsWithIndexes = await loadLogsForRange(
-      secret,
-      aztecNode,
-      start,
-      end,
-      anchorBlockNumber,
-      anchorBlockHash,
-    );
-
-    if (privateLogsWithIndexes.length === 0) {
-      break;
-    }
-
-    logs.push(...privateLogsWithIndexes.map(({ log }) => log));
-
-    const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(
-      privateLogsWithIndexes,
-      currentTimestamp,
-      finalizedBlockNumber,
-    );
-
-    // Store updates in data provider and update local variables
-    if (highestAgedIndex !== undefined) {
-      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
-    }
-
-    if (highestFinalizedIndex === undefined) {
-      // We have not found a new highest finalized index, so there is no need to move the window forward.
-      break;
-    }
-
-    if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
-      // This is just a sanity check as this should never happen.
-      throw new Error('Highest aged index lower than highest finalized index invariant violated');
-    }
-
-    await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex, jobId);
-
-    // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
-    // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
-    start = end;
-    end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
-  }
-
-  return logs;
-}

package/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -1,44 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { BlockHash } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { ExtendedDirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
-import { SiloedTag } from '@aztec/stdlib/logs';
-
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
-
-/**
- * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range and
- * `extendedSecret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and
- * `end` is exclusive.
- */
-export async function loadLogsForRange(
-  extendedSecret: ExtendedDirectionalAppTaggingSecret,
-  aztecNode: AztecNode,
-  start: number,
-  end: number,
-  anchorBlockNumber: BlockNumber,
-  anchorBlockHash: BlockHash,
-): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
-  // Derive siloed tags for the window
-  const siloedTags = await Promise.all(
-    Array.from({ length: end - start }, (_, i) => SiloedTag.compute({ extendedSecret, index: start + i })),
-  );
-
-  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-  // pagination here.
-  const logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
-
-  // Pair logs with their corresponding tagging indexes
-  const logsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }> = [];
-  for (let i = 0; i < logs.length; i++) {
-    const logsForTag = logs[i];
-    const taggingIndex = start + i;
-    for (const log of logsForTag) {
-      if (log.blockNumber <= anchorBlockNumber) {
-        logsWithIndexes.push({ log, taggingIndex });
-      }
-    }
-  }
-
-  return logsWithIndexes;
-}

package/src/tagging/sender_sync/utils/get_status_change_of_pending.ts

@@ -1,36 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { TxHash, TxStatus } from '@aztec/stdlib/tx';
-
-/**
- * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
- * dropped.
- */
-export async function getStatusChangeOfPending(
-  pending: TxHash[],
-  aztecNode: AztecNode,
-): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
-  // Get receipts for all pending tx hashes.
-  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
-
-  const txHashesToFinalize: TxHash[] = [];
-  const txHashesToDrop: TxHash[] = [];
-
-  for (let i = 0; i < receipts.length; i++) {
-    const receipt = receipts[i];
-    const txHash = pending[i];
-
-    if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
-      // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
-      // finalized.
-      txHashesToFinalize.push(txHash);
-    } else if (receipt.isDropped() || receipt.hasExecutionReverted()) {
-      // Tx was dropped or reverted --> we drop the corresponding pending indexes.
-      // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
-      txHashesToDrop.push(txHash);
-    } else {
-      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
-    }
-  }
-
-  return { txHashesToFinalize, txHashesToDrop };
-}