@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.f295ac2

package/src/private_kernel/private_kernel_oracle_impl.ts

@@ -1,132 +0,0 @@
-import { NOTE_HASH_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { Tuple } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
-import type { KeyStore } from '@aztec/key-store';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockParameter } from '@aztec/stdlib/block';
-import { computeContractClassIdPreimage, computeSaltedInitializationHash } from '@aztec/stdlib/contract';
-import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
-import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-
-import type { ContractDataProvider } from '../storage/index.js';
-import type { PrivateKernelOracle } from './private_kernel_oracle.js';
-
-// TODO: Block number should not be "latest".
-// It should be fixed at the time the proof is being simulated. I.e., it should be the same as the value defined in the constant data.
-
-/**
- * A data oracle that provides information needed for simulating a transaction.
- */
-export class PrivateKernelOracleImpl implements PrivateKernelOracle {
-  constructor(
-    private contractDataProvider: ContractDataProvider,
-    private keyStore: KeyStore,
-    private node: AztecNode,
-    private blockNumber: BlockParameter = 'latest',
-    private log = createLogger('pxe:kernel_oracle'),
-  ) {}
-
-  public async getContractAddressPreimage(address: AztecAddress) {
-    const instance = await this.contractDataProvider.getContractInstance(address);
-    if (!instance) {
-      throw new Error(`Contract instance not found when getting address preimage. Contract address: ${address}.`);
-    }
-    return {
-      saltedInitializationHash: await computeSaltedInitializationHash(instance),
-      ...instance,
-    };
-  }
-
-  public async getContractClassIdPreimage(contractClassId: Fr) {
-    const contractClass = await this.contractDataProvider.getContractClass(contractClassId);
-    if (!contractClass) {
-      throw new Error(`Contract class not found when getting class id preimage. Class id: ${contractClassId}.`);
-    }
-    return computeContractClassIdPreimage(contractClass);
-  }
-
-  public async getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector) {
-    const membershipWitness = await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
-    if (!membershipWitness) {
-      throw new Error(
-        `Membership witness not found for contract class id ${contractClassId} and selector ${selector}.`,
-      );
-    }
-    return membershipWitness;
-  }
-
-  public getVkMembershipWitness(vk: VerificationKeyAsFields) {
-    const leafIndex = getVKIndex(vk);
-    return Promise.resolve(new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
-  }
-
-  async getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>> {
-    const path = await this.node.getNoteHashSiblingPath(this.blockNumber, leafIndex);
-    return new MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>(
-      path.pathSize,
-      leafIndex,
-      path.toFields() as Tuple<Fr, typeof NOTE_HASH_TREE_HEIGHT>,
-    );
-  }
-
-  getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined> {
-    return this.node.getNullifierMembershipWitness(this.blockNumber, nullifier);
-  }
-
-  async getNoteHashTreeRoot(): Promise<Fr> {
-    const header = await this.node.getBlockHeader(this.blockNumber);
-    if (!header) {
-      throw new Error(`No block header found for block number ${this.blockNumber}`);
-    }
-    return header.state.partial.noteHashTree.root;
-  }
-
-  public getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar> {
-    return this.keyStore.getMasterSecretKey(masterPublicKey);
-  }
-
-  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
-    return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
-  }
-
-  public async getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints> {
-    const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } =
-      await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-
-    const hashLeafSlot = await computePublicDataTreeLeafSlot(
-      ProtocolContractAddress.ContractInstanceRegistry,
-      delayedPublicMutableHashSlot,
-    );
-    const updatedClassIdWitness = await this.node.getPublicDataWitness(this.blockNumber, hashLeafSlot);
-
-    if (!updatedClassIdWitness) {
-      throw new Error(`No public data tree witness found for ${hashLeafSlot}`);
-    }
-
-    const readStorage = (storageSlot: Fr) =>
-      this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
-    const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(
-      delayedPublicMutableSlot,
-      readStorage,
-    );
-
-    return new UpdatedClassIdHints(
-      new MembershipWitness(
-        PUBLIC_DATA_TREE_HEIGHT,
-        updatedClassIdWitness.index,
-        updatedClassIdWitness.siblingPath.toTuple(),
-      ),
-      updatedClassIdWitness.leafPreimage,
-      delayedPublicMutableValues,
-    );
-  }
-}

package/src/storage/address_data_provider/index.ts

@@ -1 +0,0 @@
-export { AddressDataProvider } from './address_data_provider.js';

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -1,147 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-export class CapsuleDataProvider {
-  #store: AztecAsyncKVStore;
-
-  // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
-  #capsules: AztecAsyncMap<string, Buffer>;
-
-  logger: Logger;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#capsules = this.#store.openMap('capsules');
-
-    this.logger = createLogger('pxe:capsule-data-provider');
-  }
-
-  async storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
-    await this.#capsules.set(dbSlotToKey(contractAddress, slot), Buffer.concat(capsule.map(value => value.toBuffer())));
-  }
-
-  async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
-    const dataBuffer = await this.#capsules.getAsync(dbSlotToKey(contractAddress, slot));
-    if (!dataBuffer) {
-      this.logger.trace(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
-      return null;
-    }
-    const capsule: Fr[] = [];
-    for (let i = 0; i < dataBuffer.length; i += Fr.SIZE_IN_BYTES) {
-      capsule.push(Fr.fromBuffer(dataBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
-    }
-    return capsule;
-  }
-
-  async deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
-    await this.#capsules.delete(dbSlotToKey(contractAddress, slot));
-  }
-
-  copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      // In order to support overlapping source and destination regions, we need to check the relative positions of source
-      // and destination. If destination is ahead of source, then by the time we overwrite source elements using forward
-      // indexes we'll have already read those. On the contrary, if source is ahead of destination we need to use backward
-      // indexes to avoid reading elements that've been overwritten.
-
-      const indexes = Array.from(Array(numEntries).keys());
-      if (srcSlot.lt(dstSlot)) {
-        indexes.reverse();
-      }
-
-      for (const i of indexes) {
-        const currentSrcSlot = dbSlotToKey(contractAddress, srcSlot.add(new Fr(i)));
-        const currentDstSlot = dbSlotToKey(contractAddress, dstSlot.add(new Fr(i)));
-
-        const toCopy = await this.#capsules.getAsync(currentSrcSlot);
-        if (!toCopy) {
-          throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
-        }
-
-        await this.#capsules.set(currentDstSlot, toCopy);
-      }
-    });
-  }
-
-  /**
-   * Appends multiple capsules to a capsule array stored at the base slot.
-   * The array length is stored at the base slot, and elements are stored in consecutive slots after it.
-   * All operations are performed in a single transaction.
-   * @param contractAddress - The contract address that owns the capsule array
-   * @param baseSlot - The slot where the array length is stored
-   * @param content - Array of capsule data to append
-   */
-  appendToCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][]): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      // Load current length, defaulting to 0 if not found
-      const lengthData = await this.loadCapsule(contractAddress, baseSlot);
-      const currentLength = lengthData ? lengthData[0].toNumber() : 0;
-
-      // Store each capsule at consecutive slots after baseSlot + 1 + currentLength
-      for (let i = 0; i < content.length; i++) {
-        const nextSlot = arraySlot(baseSlot, currentLength + i);
-        await this.storeCapsule(contractAddress, nextSlot, content[i]);
-      }
-
-      // Update length to include all new capsules
-      const newLength = currentLength + content.length;
-      await this.storeCapsule(contractAddress, baseSlot, [new Fr(newLength)]);
-    });
-  }
-
-  readCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr): Promise<Fr[][]> {
-    return this.#store.transactionAsync(async () => {
-      // Load length, defaulting to 0 if not found
-      const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
-      const length = maybeLength ? maybeLength[0].toBigInt() : 0n;
-
-      const values: Fr[][] = [];
-
-      // Read each capsule at consecutive slots after baseSlot
-      for (let i = 0; i < length; i++) {
-        const currentValue = await this.loadCapsule(contractAddress, arraySlot(baseSlot, i));
-        if (currentValue == undefined) {
-          throw new Error(
-            `Expected non-empty value at capsule array in base slot ${baseSlot} at index ${i} for contract ${contractAddress}`,
-          );
-        }
-
-        values.push(currentValue);
-      }
-
-      return values;
-    });
-  }
-
-  setCapsuleArray(contractAddress: AztecAddress, baseSlot: Fr, content: Fr[][]) {
-    return this.#store.transactionAsync(async () => {
-      // Load current length, defaulting to 0 if not found
-      const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
-      const originalLength = maybeLength ? maybeLength[0].toNumber() : 0;
-
-      // Set the new length
-      await this.storeCapsule(contractAddress, baseSlot, [new Fr(content.length)]);
-
-      // Store the new content, possibly overwriting existing values
-      for (let i = 0; i < content.length; i++) {
-        await this.storeCapsule(contractAddress, arraySlot(baseSlot, i), content[i]);
-      }
-
-      // Clear any stragglers
-      for (let i = content.length; i < originalLength; i++) {
-        await this.deleteCapsule(contractAddress, arraySlot(baseSlot, i));
-      }
-    });
-  }
-}
-
-function dbSlotToKey(contractAddress: AztecAddress, slot: Fr): string {
-  return `${contractAddress.toString()}:${slot.toString()}`;
-}
-
-function arraySlot(baseSlot: Fr, index: number) {
-  return baseSlot.add(new Fr(1)).add(new Fr(index));
-}

package/src/storage/capsule_data_provider/index.ts

@@ -1 +0,0 @@
-export { CapsuleDataProvider } from './capsule_data_provider.js';

package/src/storage/contract_data_provider/index.ts

@@ -1 +0,0 @@
-export { ContractDataProvider } from './contract_data_provider.js';

package/src/storage/note_data_provider/index.ts

@@ -1,2 +0,0 @@
-export { NoteDao } from '@aztec/stdlib/note';
-export { NoteDataProvider } from './note_data_provider.js';

package/src/storage/private_event_data_provider/private_event_data_provider.ts

@@ -1,143 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { EventSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
-import { TxHash } from '@aztec/stdlib/tx';
-
-import type { PrivateEvent } from '../../pxe.js';
-
-interface PrivateEventEntry {
-  msgContent: Buffer;
-  blockNumber: number;
-  blockHash: Buffer;
-  eventCommitmentIndex: number;
-  txHash: Buffer;
-}
-
-/**
- * Stores decrypted private event logs.
- */
-export class PrivateEventDataProvider {
-  #store: AztecAsyncKVStore;
-  /** Array storing the actual private event log entries containing the log content and block number */
-  #eventLogs: AztecAsyncArray<PrivateEventEntry>;
-  /** Map from contract_address_recipient_eventSelector to array of indices into #eventLogs for efficient lookup */
-  #eventLogIndex: AztecAsyncMap<string, number[]>;
-  /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
-  #seenLogs: AztecAsyncMap<number, boolean>;
-
-  logger = createLogger('private_event_data_provider');
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-    this.#eventLogs = this.#store.openArray('private_event_logs');
-    this.#eventLogIndex = this.#store.openMap('private_event_log_index');
-    this.#seenLogs = this.#store.openMap('seen_logs');
-  }
-
-  /**
-   * Store a private event log.
-   * @param contractAddress - The address of the contract that emitted the event.
-   * @param recipient - The recipient of the event.
-   * @param eventSelector - The event selector of the event.
-   * @param msgContent - The content of the event.
-   * @param txHash - The transaction hash of the event log.
-   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
-   * @param blockNumber - The block number in which the event was emitted.
-   */
-  storePrivateEventLog(
-    contractAddress: AztecAddress,
-    recipient: AztecAddress,
-    eventSelector: EventSelector,
-    msgContent: Fr[],
-    txHash: TxHash,
-    eventCommitmentIndex: number,
-    blockNumber: number,
-    blockHash: L2BlockHash,
-  ): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
-
-      // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
-      const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
-      if (hasBeenSeen) {
-        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), eventCommitmentIndex });
-        return;
-      }
-
-      this.logger.verbose('storing private event log', { contractAddress, recipient, msgContent, blockNumber });
-
-      const index = await this.#eventLogs.lengthAsync();
-      await this.#eventLogs.push({
-        msgContent: serializeToBuffer(msgContent),
-        blockNumber,
-        blockHash: blockHash.toBuffer(),
-        eventCommitmentIndex,
-        txHash: txHash.toBuffer(),
-      });
-
-      const existingIndices = (await this.#eventLogIndex.getAsync(key)) || [];
-      await this.#eventLogIndex.set(key, [...existingIndices, index]);
-
-      // Mark this log as seen using eventCommitmentIndex
-      await this.#seenLogs.set(eventCommitmentIndex, true);
-    });
-  }
-
-  /**
-   * Returns the private events given search parameters.
-   * @param contractAddress - The address of the contract to get events from.
-   * @param from - The block number to search from.
-   * @param numBlocks - The amount of blocks to search.
-   * @param recipients - The addresses that decrypted the logs.
-   * @param eventSelector - The event selector to filter by.
-   * @returns - The event log contents.
-   */
-  public async getPrivateEvents(
-    contractAddress: AztecAddress,
-    from: number,
-    numBlocks: number,
-    recipients: AztecAddress[],
-    eventSelector: EventSelector,
-  ): Promise<PrivateEvent[]> {
-    const events: Array<{ eventCommitmentIndex: number; event: PrivateEvent }> = [];
-
-    for (const recipient of recipients) {
-      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
-      const indices = (await this.#eventLogIndex.getAsync(key)) || [];
-
-      for (const index of indices) {
-        const entry = await this.#eventLogs.atAsync(index);
-        if (!entry || entry.blockNumber < from || entry.blockNumber >= from + numBlocks) {
-          continue;
-        }
-
-        // Convert buffer back to Fr array
-        const reader = BufferReader.asReader(entry.msgContent);
-        const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
-        const msgContent = reader.readArray(numFields, Fr);
-        const txHash = TxHash.fromBuffer(entry.txHash);
-        const blockHash = L2BlockHash.fromBuffer(entry.blockHash);
-
-        events.push({
-          eventCommitmentIndex: entry.eventCommitmentIndex,
-          event: {
-            packedEvent: msgContent,
-            blockNumber: entry.blockNumber,
-            recipient,
-            txHash,
-            blockHash,
-            eventSelector,
-          },
-        });
-      }
-    }
-
-    // Sort by eventCommitmentIndex only
-    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
-    return events.map(ev => ev.event);
-  }
-}

package/src/storage/sync_data_provider/index.ts

@@ -1 +0,0 @@
-export { SyncDataProvider } from './sync_data_provider.js';

package/src/storage/tagging_data_provider/index.ts

@@ -1 +0,0 @@
-export { TaggingDataProvider } from './tagging_data_provider.js';

package/src/storage/tagging_data_provider/tagging_data_provider.ts

@@ -1,120 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-
-export class TaggingDataProvider {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  // Stores the last used index for each directional app tagging secret. Taking into account whether we are
-  // requesting the index as a sender or as a recipient because the sender and recipient can be in the same PXE.
-  #lastUsedIndexesAsSenders: AztecAsyncMap<string, number>;
-  #lastUsedIndexesAsRecipients: AztecAsyncMap<string, number>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-
-    this.#lastUsedIndexesAsSenders = this.#store.openMap('last_used_indexes_as_senders');
-    this.#lastUsedIndexesAsRecipients = this.#store.openMap('last_used_indexes_as_recipients');
-  }
-
-  /**
-   * Sets the last used indexes when sending a log.
-   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
-   * updated in the db.
-   * @throws If any two pre tags contain the same directional app tagging secret
-   */
-  setLastUsedIndexesAsSender(preTags: PreTag[]) {
-    this.#assertUniqueSecrets(preTags, 'sender');
-
-    return Promise.all(
-      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsSenders.set(secret.toString(), index)),
-    );
-  }
-
-  /**
-   * Sets the last used indexes when looking for logs.
-   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
-   * updated in the db.
-   * @throws If any two pre tags contain the same directional app tagging secret
-   */
-  setLastUsedIndexesAsRecipient(preTags: PreTag[]) {
-    this.#assertUniqueSecrets(preTags, 'recipient');
-
-    return Promise.all(
-      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsRecipients.set(secret.toString(), index)),
-    );
-  }
-
-  // It should never happen that we would receive any two pre tags on the input containing the same directional app
-  // tagging secret as everywhere we always just apply the largest index. Hence this check is a good way to catch
-  // bugs.
-  #assertUniqueSecrets(preTags: PreTag[], role: 'sender' | 'recipient'): void {
-    const secretStrings = preTags.map(({ secret }) => secret.toString());
-    const uniqueSecrets = new Set(secretStrings);
-    if (uniqueSecrets.size !== secretStrings.length) {
-      throw new Error(`Duplicate secrets found when setting last used indexes as ${role}`);
-    }
-  }
-
-  /**
-   * Returns the last used index when sending a log with a given secret.
-   * @param secret - The directional app tagging secret.
-   * @returns The last used index for the given directional app tagging secret, or undefined if not found.
-   */
-  async getLastUsedIndexesAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
-    return await this.#lastUsedIndexesAsSenders.getAsync(secret.toString());
-  }
-
-  /**
-   * Returns the last used indexes when looking for logs as a recipient.
-   * @param secrets - The directional app tagging secrets to obtain the indexes for.
-   * @returns The last used indexes for the given directional app tagging secrets, or undefined if have never yet found
-   * a log for a given secret.
-   */
-  getLastUsedIndexesAsRecipient(secrets: DirectionalAppTaggingSecret[]): Promise<(number | undefined)[]> {
-    return Promise.all(secrets.map(secret => this.#lastUsedIndexesAsRecipients.getAsync(secret.toString())));
-  }
-
-  resetNoteSyncData(): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      const keysForSenders = await toArray(this.#lastUsedIndexesAsSenders.keysAsync());
-      await Promise.all(keysForSenders.map(secret => this.#lastUsedIndexesAsSenders.delete(secret)));
-      const keysForRecipients = await toArray(this.#lastUsedIndexesAsRecipients.keysAsync());
-      await Promise.all(keysForRecipients.map(secret => this.#lastUsedIndexesAsRecipients.delete(secret)));
-    });
-  }
-
-  async addSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (await this.#addressBook.hasAsync(address.toString())) {
-      return false;
-    }
-
-    await this.#addressBook.set(address.toString(), true);
-
-    return true;
-  }
-
-  async getSenderAddresses(): Promise<AztecAddress[]> {
-    return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-  }
-
-  async removeSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (!(await this.#addressBook.hasAsync(address.toString()))) {
-      return false;
-    }
-
-    await this.#addressBook.delete(address.toString());
-
-    return true;
-  }
-
-  async getSize() {
-    const addressesCount = (await toArray(this.#addressBook.keysAsync())).length;
-    // All keys are addresses
-    return 3 * addressesCount * AztecAddress.SIZE_IN_BYTES;
-  }
-}

package/src/synchronizer/index.ts

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

package/src/tagging/siloed_tag.ts

@@ -1,22 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import type { Tag } from './tag.js';
-
-/**
- * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
- * address that emitted the log.
- */
-export class SiloedTag {
-  private constructor(public readonly value: Fr) {}
-
-  static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
-    const siloedTag = await poseidon2Hash([app, tag.value]);
-    return new SiloedTag(siloedTag);
-  }
-
-  toString(): string {
-    return this.value.toString();
-  }
-}

package/src/tagging/tag.ts

@@ -1,16 +0,0 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
-import type { PreTag } from '@aztec/stdlib/logs';
-
-/**
- * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
- * with a contract address by kernels before being included in the final log.
- */
-export class Tag {
-  private constructor(public readonly value: Fr) {}
-
-  static async compute(preTag: PreTag): Promise<Tag> {
-    const tag = await poseidon2Hash([preTag.secret.value, preTag.index]);
-    return new Tag(tag);
-  }
-}

package/src/tagging/utils.ts

@@ -1,31 +0,0 @@
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-
-// TODO(benesjan): Make this return tags instead - this will moves some complexity from syncTaggedLogs
-export function getPreTagsForTheWindow(
-  secretsAndWindows: { secret: DirectionalAppTaggingSecret; leftMostIndex: number; rightMostIndex: number }[],
-): PreTag[] {
-  const secrets = [];
-  for (const secretAndWindow of secretsAndWindows) {
-    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
-      secrets.push({ secret: secretAndWindow.secret, index: i });
-    }
-  }
-  return secrets;
-}
-
-/**
- * Creates a map from directional app tagging secret to initial index.
- * @param preTags - The pre tags to get the initial indexes map from.
- * @returns The map from directional app tagging secret to initial index.
- */
-export function getInitialIndexesMap(preTags: { secret: DirectionalAppTaggingSecret; index: number | undefined }[]): {
-  [k: string]: number;
-} {
-  const initialIndexes: { [k: string]: number } = {};
-
-  for (const preTag of preTags) {
-    initialIndexes[preTag.secret.toString()] = preTag.index ?? 0;
-  }
-
-  return initialIndexes;
-}