@aztec/stdlib 0.82.2 → 0.82.3-nightly.20250403

package/src/epoch-helpers/index.ts

@@ -26,6 +26,14 @@ export const L1RollupConstantsSchema = z.object({
   ethereumSlotDuration: z.number(),
 }) satisfies ZodFor<L1RollupConstants>;
 
+/** Returns the timestamp for a given L2 slot. */
+export function getTimestampForSlot(
+  slot: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+) {
+  return constants.l1GenesisTime + slot * BigInt(constants.slotDuration);
+}
+
 /** Returns the slot number for a given timestamp. */
 export function getSlotAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>) {
   return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(constants.slotDuration);

package/src/file-store/factory.ts

@@ -0,0 +1,61 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import { GoogleCloudFileStore } from './gcs.js';
+import { HttpFileStore } from './http.js';
+import type { FileStore, ReadOnlyFileStore } from './interface.js';
+import { LocalFileStore } from './local.js';
+
+const supportedExamples = [
+  `gs://bucket-name/path/to/store`,
+  `file:///absolute/local/path/to/store`,
+  `https://host/path`,
+];
+
+export async function createFileStore(config: string, logger?: Logger): Promise<FileStore>;
+export async function createFileStore(config: undefined, logger?: Logger): Promise<undefined>;
+export async function createFileStore(
+  config: string | undefined,
+  logger = createLogger('stdlib:file-store'),
+): Promise<FileStore | undefined> {
+  if (config === undefined) {
+    return undefined;
+  } else if (config.startsWith('file://')) {
+    const url = new URL(config);
+    if (url.host) {
+      throw new Error(`File store URL only supports local paths (got host ${url.host} from ${config})`);
+    }
+    const path = url.pathname;
+    logger.info(`Creating local file file store at ${path}`);
+    return new LocalFileStore(path);
+  } else if (config.startsWith('gs://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      logger.info(`Creating google cloud file store at ${bucket} ${path}`);
+      const store = new GoogleCloudFileStore(bucket, path);
+      await store.checkCredentials();
+      return store;
+    } catch (err) {
+      throw new Error(`Invalid google cloud store definition: '${config}'.`);
+    }
+  } else {
+    throw new Error(`Unknown file store config: '${config}'. Supported values are ${supportedExamples.join(', ')}.`);
+  }
+}
+
+export async function createReadOnlyFileStore(config: string, logger?: Logger): Promise<ReadOnlyFileStore>;
+export async function createReadOnlyFileStore(config: undefined, logger?: Logger): Promise<undefined>;
+export async function createReadOnlyFileStore(
+  config: string | undefined,
+  logger = createLogger('stdlib:file-store'),
+): Promise<ReadOnlyFileStore | undefined> {
+  if (config === undefined) {
+    return undefined;
+  } else if (config.startsWith('http://') || config.startsWith('https://')) {
+    logger.info(`Creating read-only HTTP file store at ${config}`);
+    return new HttpFileStore(config, logger);
+  } else {
+    return await createFileStore(config, logger);
+  }
+}

package/src/file-store/gcs.ts

@@ -0,0 +1,121 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import { File, Storage, type UploadOptions } from '@google-cloud/storage';
+import { join } from 'path';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+export class GoogleCloudFileStore implements FileStore {
+  private readonly storage: Storage;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    private readonly log: Logger = createLogger('stdlib:gcs-file-store'),
+  ) {
+    this.storage = new Storage();
+  }
+
+  public async checkCredentials() {
+    await this.storage.getServiceAccount();
+  }
+
+  public async save(
+    path: string,
+    data: Buffer,
+    opts: FileStoreSaveOptions = { public: false, metadata: {}, compress: false },
+  ): Promise<string> {
+    const fullPath = this.getFullPath(path);
+    try {
+      const bucket = this.storage.bucket(this.bucketName);
+      const file = bucket.file(fullPath);
+      await file.save(data, { metadata: opts.metadata, gzip: opts.compress });
+      return this.handleUploadedFile(file, opts);
+    } catch (err: any) {
+      throw new Error(`Error saving file to google cloud storage at ${fullPath}: ${err.message ?? err}`);
+    }
+  }
+
+  public async upload(
+    destPath: string,
+    srcPath: string,
+    opts: FileStoreSaveOptions = { compress: true, public: false, metadata: {} },
+  ): Promise<string> {
+    const fullPath = this.getFullPath(destPath);
+    try {
+      const bucket = this.storage.bucket(this.bucketName);
+      const file = bucket.file(fullPath);
+      const uploadOpts: UploadOptions = {
+        destination: file,
+        gzip: opts.compress,
+        metadata: opts.metadata,
+      };
+      await bucket.upload(srcPath, uploadOpts);
+      return this.handleUploadedFile(file, opts);
+    } catch (err: any) {
+      throw new Error(`Error saving file to google cloud storage at ${fullPath}: ${err.message ?? err}`);
+    }
+  }
+
+  private async handleUploadedFile(file: File, opts: { public?: boolean }): Promise<string> {
+    if (opts.public) {
+      try {
+        if (!(await file.isPublic())) {
+          await file.makePublic();
+        }
+      } catch (err: any) {
+        this.log.warn(
+          `Error making file ${file.name} public: ${
+            err.message ?? err
+          }. This is expected if we handle public access at the bucket level.`,
+        );
+      }
+      return file.publicUrl().replaceAll('%2F', '/');
+    } else {
+      return file.cloudStorageURI.toString();
+    }
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const file = await this.getFileObject(pathOrUrlStr);
+    const contents = await file.download();
+    return contents[0];
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const file = await this.getFileObject(pathOrUrlStr);
+    await file.download({ destination: destPath });
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    const { bucketName, fullPath } = this.getBucketAndFullPath(pathOrUrlStr);
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(fullPath);
+    const [exists] = await file.exists();
+    return exists;
+  }
+
+  private async getFileObject(pathOrUrlStr: string): Promise<File> {
+    const { bucketName, fullPath } = this.getBucketAndFullPath(pathOrUrlStr);
+    const bucket = this.storage.bucket(bucketName);
+    const file = bucket.file(fullPath);
+    if (!(await file.exists())) {
+      throw new Error(`File at ${fullPath} in gcs bucket ${bucketName} does not exist`);
+    }
+    return file;
+  }
+
+  private getBucketAndFullPath(pathOrUrlStr: string): { bucketName: string; fullPath: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      // Note that we accept reading from anywhere, not just our bucket
+      return { fullPath: url.pathname.replace(/^\/+/, ''), bucketName: url.host };
+    } else {
+      return { fullPath: this.getFullPath(pathOrUrlStr), bucketName: this.bucketName };
+    }
+  }
+
+  private getFullPath(path: string): string {
+    return this.basePath && this.basePath.length > 0 ? join(this.basePath, path) : path;
+  }
+}

package/src/file-store/http.ts

@@ -0,0 +1,58 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+
+import { createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+
+import type { ReadOnlyFileStore } from './interface.js';
+
+export class HttpFileStore implements ReadOnlyFileStore {
+  private readonly fetch: typeof fetch;
+
+  constructor(private readonly baseUrl: string, private readonly log: Logger = createLogger('stdlib:http-file-store')) {
+    this.fetch = async (...args: Parameters<typeof fetch>): Promise<Response> => {
+      return await retry(
+        () => fetch(...args),
+        `Fetching ${args[0]}`,
+        makeBackoff([1, 1, 3]),
+        this.log,
+        /*failSilently=*/ true,
+      );
+    };
+  }
+
+  public async read(pathOrUrl: string): Promise<Buffer> {
+    const url = this.getUrl(pathOrUrl);
+    const response = await this.fetch(url);
+    if (response.ok) {
+      return Buffer.from(await response.arrayBuffer());
+    } else {
+      throw new Error(`Error fetching file from ${url}: ${response.statusText}`);
+    }
+  }
+
+  public async download(pathOrUrl: string, destPath: string): Promise<void> {
+    const url = this.getUrl(pathOrUrl);
+    const response = await this.fetch(url);
+    if (response.ok) {
+      await mkdir(dirname(destPath), { recursive: true });
+      // Typescript complains about Readable.fromWeb, hence the cast
+      await finished(Readable.fromWeb(response.body! as any).pipe(createWriteStream(destPath)));
+    } else {
+      throw new Error(`Error fetching file from ${url}: ${response.statusText}`);
+    }
+  }
+
+  public async exists(pathOrUrl: string): Promise<boolean> {
+    const url = this.getUrl(pathOrUrl);
+    const response = await this.fetch(url);
+    return response.ok;
+  }
+
+  private getUrl(path: string): string {
+    return URL.canParse(path) ? path : `${this.baseUrl.replace(/\/$/, '')}/${path}`;
+  }
+}

package/src/file-store/index.ts

@@ -0,0 +1,2 @@
+export * from './interface.js';
+export * from './factory.js';

package/src/file-store/interface.ts

@@ -0,0 +1,19 @@
+/** Simple read-only file store. */
+export interface ReadOnlyFileStore {
+  /** Reads a file given a path, or an URI as returned by calling `save`. Returns file contents. */
+  read(pathOrUrl: string): Promise<Buffer>;
+  /** Downloads a file given a path, or an URI as returned by calling `save`. Saves file to local path. */
+  download(pathOrUrlStr: string, destPath: string): Promise<void>;
+  /** Returns whether a file at the given path or URI exists. */
+  exists(pathOrUrl: string): Promise<boolean>;
+}
+
+export type FileStoreSaveOptions = { public?: boolean; metadata?: Record<string, string>; compress?: boolean };
+
+/** Simple file store. */
+export interface FileStore extends ReadOnlyFileStore {
+  /** Saves contents to the given path. Returns an URI that can be used later to `read` the file. */
+  save(path: string, data: Buffer, opts?: FileStoreSaveOptions): Promise<string>;
+  /** Uploads contents from a local file. Returns an URI that can be used later to `read` the file. */
+  upload(destPath: string, srcPath: string, opts?: FileStoreSaveOptions): Promise<string>;
+}

package/src/file-store/local.ts

@@ -0,0 +1,46 @@
+import { access, mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+
+import type { FileStore } from './interface.js';
+
+export class LocalFileStore implements FileStore {
+  constructor(private readonly basePath: string) {}
+
+  public async save(path: string, data: Buffer): Promise<string> {
+    const fullPath = this.getFullPath(path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, data);
+    return `file://${fullPath}`;
+  }
+
+  public async upload(destPath: string, srcPath: string, _opts: { compress: boolean }): Promise<string> {
+    const data = await readFile(srcPath);
+    return this.save(destPath, data);
+  }
+
+  public read(pathOrUrlStr: string): Promise<Buffer> {
+    const fullPath = this.getFullPath(pathOrUrlStr);
+    return readFile(fullPath);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const data = await this.read(pathOrUrlStr);
+    const fullPath = this.getFullPath(destPath);
+    await writeFile(fullPath, data);
+  }
+
+  public exists(pathOrUrlStr: string): Promise<boolean> {
+    const fullPath = this.getFullPath(pathOrUrlStr);
+    return access(fullPath)
+      .then(() => true)
+      .catch(() => false);
+  }
+
+  private getFullPath(pathOrUrl: string): string {
+    if (URL.canParse(pathOrUrl)) {
+      return new URL(pathOrUrl).pathname;
+    } else {
+      return resolve(this.basePath, pathOrUrl);
+    }
+  }
+}

package/src/interfaces/aztec-node-admin.ts

@@ -17,13 +17,23 @@ export interface AztecNodeAdmin {
    */
   setConfig(config: Partial<SequencerConfig & ProverConfig>): Promise<void>;
 
-  /** Forces the next block to be built bypassing all time and pending checks. Useful for testing. */
+  /**
+   * Forces the next block to be built bypassing all time and pending checks.
+   * Useful for testing.
+   */
   flushTxs(): Promise<void>;
+
+  /**
+   * Pauses syncing, creates a backup of archiver and world-state databases, and uploads them. Returns immediately.
+   * @param location - The location to upload the snapshot to.
+   */
+  startSnapshotUpload(location: string): Promise<void>;
 }
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
   setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
   flushTxs: z.function().returns(z.void()),
+  startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/aztec-node.ts

@@ -46,6 +46,8 @@ import {
   TxValidationResultSchema,
 } from '../tx/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
+import { ValidatorsStatsSchema } from '../validators/schemas.js';
+import type { ValidatorsStats } from '../validators/types.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 import {
   type GetContractClassLogsResponse,
@@ -379,6 +381,9 @@ export interface AztecNode
    */
   getBlockHeader(blockNumber?: L2BlockNumber): Promise<BlockHeader | undefined>;
 
+  /** Returns stats for validators if enabled. */
+  getValidatorsStats(): Promise<ValidatorsStats>;
+
   /**
    * Simulates the public part of a transaction with the current state.
    * This currently just checks that the transaction execution succeeds.
@@ -525,6 +530,8 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getBlockHeader: z.function().args(optional(L2BlockNumberSchema)).returns(BlockHeader.schema.optional()),
 
+  getValidatorsStats: z.function().returns(ValidatorsStatsSchema),
+
   simulatePublicCalls: z.function().args(Tx.schema, optional(z.boolean())).returns(PublicSimulationOutput.schema),
 
   isValidTx: z

package/src/interfaces/p2p.ts

@@ -50,6 +50,9 @@ export interface P2PClient extends P2PApiWithoutAttestations {
    * @returns BlockAttestations
    */
   getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+
+  /** Manually adds an attestation to the p2p client attestation pool. */
+  addAttestation(attestation: BlockAttestation): Promise<void>;
 }
 
 export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
@@ -64,4 +67,5 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxs: z.function().returns(z.array(Tx.schema)),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
+  addAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };

package/src/interfaces/prover-client.ts

@@ -26,7 +26,7 @@ export type ProverConfig = ActualProverConfig & {
   /** The URL to the Aztec node to take proving jobs from */
   nodeUrl?: string;
   /** Identifier of the prover */
-  proverId: Fr;
+  proverId?: Fr;
   /** Number of proving agents to start within the prover. */
   proverAgentCount: number;
   /** Store for failed proof inputs. */
@@ -36,7 +36,7 @@ export type ProverConfig = ActualProverConfig & {
 export const ProverConfigSchema = z.object({
   nodeUrl: z.string().optional(),
   realProofs: z.boolean(),
-  proverId: schemas.Fr,
+  proverId: schemas.Fr.optional(),
   proverTestDelayType: z.enum(['fixed', 'realistic']),
   proverTestDelayMs: z.number(),
   proverTestDelayFactor: z.number(),
@@ -55,9 +55,8 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   },
   proverId: {
     env: 'PROVER_ID',
-    parseEnv: (val: string) => parseProverId(val),
-    description: 'Identifier of the prover',
-    defaultValue: Fr.ZERO,
+    parseEnv: (val?: string) => parseProverId(val),
+    description: 'Hex value that identifies the prover. Defaults to the address used for submitting proofs if not set.',
   },
   proverTestDelayType: {
     env: 'PROVER_TEST_DELAY_TYPE',
@@ -85,8 +84,11 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   },
 };
 
-function parseProverId(str: string) {
-  return Fr.fromHexString(str.startsWith('0x') ? str : Buffer.from(str, 'utf8').toString('hex'));
+function parseProverId(str?: string) {
+  if (!str) {
+    return undefined;
+  }
+  return Fr.fromHexString(str);
 }
 
 /**

package/src/interfaces/prover-node.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 
+import { type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
 import { type ApiSchemaFor, schemas } from '../schemas/index.js';
+import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_state.js';
 
 const EpochProvingJobState = [
   'initialized',
@@ -31,6 +33,10 @@ export interface ProverNodeApi {
   getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]>;
 
   startProof(epochNumber: number): Promise<void>;
+
+  getL2Tips(): Promise<L2Tips>;
+
+  getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
 }
 
 /** Schemas for prover node API functions. */
@@ -41,4 +47,8 @@ export const ProverNodeApiSchema: ApiSchemaFor<ProverNodeApi> = {
     .returns(z.array(z.object({ uuid: z.string(), status: z.enum(EpochProvingJobState), epochNumber: z.number() }))),
 
   startProof: z.function().args(schemas.Integer).returns(z.void()),
+
+  getL2Tips: z.function().args().returns(L2TipsSchema),
+
+  getWorldStateSyncStatus: z.function().args().returns(WorldStateSyncStatusSchema),
 };

package/src/interfaces/pxe.ts

@@ -1,5 +1,5 @@
 import { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr, Point } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
 import type { ApiSchemaFor, ZodFor } from '@aztec/foundation/schemas';
 import { SiblingPath } from '@aztec/foundation/trees';
 
@@ -129,7 +129,7 @@ export interface PXE {
 
   /**
    * Proves the private portion of a simulated transaction, ready to send to the network
-   * (where valiators prove the public portion).
+   * (where validators prove the public portion).
    *
    * @param txRequest - An authenticated tx request ready for proving
    * @param privateExecutionResult - The result of the private execution of the transaction
@@ -313,7 +313,7 @@ export interface PXE {
 
   /**
    * Returns the information about the server's node. Includes current Node version, compatible Noir version,
-   * L1 chain identifier, protocol version, and L1 address of the rollup contract.
+   * L1 chain identifier, rollup version, and L1 address of the rollup contract.
    * @returns - The node information.
    */
   getNodeInfo(): Promise<NodeInfo>;
@@ -354,13 +354,20 @@ export interface PXE {
 
   /**
    * Returns the private events given search parameters.
+   * @param contractAddress - The address of the contract to get events from.
    * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
    * @param from - The block number to search from.
-   * @param limit - The amount of blocks to search.
-   * @param vpks - The incoming viewing public keys that can decrypt the log.
+   * @param numBlocks - The amount of blocks to search.
+   * @param recipients - The addresses that decrypted the logs.
    * @returns - The deserialized events.
    */
-  getPrivateEvents<T>(eventMetadata: EventMetadataDefinition, from: number, limit: number, vpks: Point[]): Promise<T[]>;
+  getPrivateEvents<T>(
+    contractAddress: AztecAddress,
+    eventMetadata: EventMetadataDefinition,
+    from: number,
+    numBlocks: number,
+    recipients: AztecAddress[],
+  ): Promise<T[]>;
 
   /**
    * Returns the public events given search parameters.
@@ -505,7 +512,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
   getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),
   getPrivateEvents: z
     .function()
-    .args(EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.Point))
+    .args(schemas.AztecAddress, EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.AztecAddress))
     .returns(z.array(AbiDecodedSchema)),
   getPublicEvents: z
     .function()

package/src/interfaces/service.ts

@@ -11,6 +11,9 @@ export interface Service {
 
   /** Stops the service. */
   stop(): Promise<void>;
+
+  /** Resumes the service after it was stopped */
+  resume(): void;
 }
 
 /** Tries to call stop on a given object and awaits it. Logs any errors and does not rethrow. */
@@ -23,3 +26,13 @@ export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise
     logger?.error(`Error stopping service ${(service as object).constructor?.name}: ${err}`);
   }
 }
+
+export function tryRestart(service: Maybe<Service>, logger?: Logger) {
+  try {
+    return typeof service === 'object' && service && 'restart' in service && typeof service.restart === 'function'
+      ? service.restart()
+      : Promise.resolve();
+  } catch (err) {
+    logger?.error(`Error restarting service ${(service as object).constructor?.name}: ${err}`);
+  }
+}

package/src/interfaces/world_state.ts

@@ -1,7 +1,10 @@
 import { z } from 'zod';
 
+import type { SnapshotDataKeys } from '../snapshots/types.js';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from './merkle_tree_operations.js';
 
+export type { SnapshotDataKeys };
+
 /**
  * Defines the possible states of the world state synchronizer.
  */
@@ -41,37 +44,36 @@ export interface ForkMerkleTreeOperations {
 
   /** Gets a handle that allows reading the state as it was at the given block number. */
   getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+
+  /** Backups the db to the target path. */
+  backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
 }
 
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
-  /**
-   * Starts the synchronizer.
-   * @returns A promise that resolves once the initial sync is completed.
-   */
+  /** Starts the synchronizer. */
   start(): void;
 
-  /**
-   * Returns the current status of the synchronizer.
-   * @returns The current status of the synchronizer.
-   */
+  /** Returns the current status of the synchronizer. */
   status(): Promise<WorldStateSynchronizerStatus>;
 
-  /**
-   * Stops the synchronizer.
-   */
+  /** Stops the synchronizer and its database. */
   stop(): Promise<void>;
 
+  /** Stops the synchronizer from syncing, but keeps the database online. */
+  stopSync(): Promise<void>;
+
+  /** Resumes synching after a stopSync call. */
+  resumeSync(): void;
+
   /**
    * Forces an immediate sync to an optionally provided minimum block number
-   * @param minBlockNumber - The minimum block number that we must sync to
+   * @param minBlockNumber - The minimum block number that we must sync to (may sync further)
    * @returns A promise that resolves with the block number the world state was synced to
    */
   syncImmediate(minBlockNumber?: number): Promise<number>;
 
-  /**
-   * Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data.
-   */
+  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
   getCommitted(): MerkleTreeReadOperations;
 }
 

package/src/keys/derivation.ts

@@ -1,5 +1,5 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { Grumpkin, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
+import { Grumpkin, poseidon2Hash, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
 import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
 
 import { AztecAddress } from '../aztec-address/index.js';
@@ -123,11 +123,7 @@ export async function deriveKeys(secretKey: Fr) {
 }
 
 // Returns shared tagging secret computed with Diffie-Hellman key exchange.
-export async function computeTaggingSecretPoint(
-  knownAddress: CompleteAddress,
-  ivsk: Fq,
-  externalAddress: AztecAddress,
-) {
+async function computeTaggingSecretPoint(knownAddress: CompleteAddress, ivsk: Fq, externalAddress: AztecAddress) {
   const knownPreaddress = await computePreaddress(await knownAddress.publicKeys.hash(), knownAddress.partialAddress);
   // TODO: #8970 - Computation of address point from x coordinate might fail
   const externalAddressPoint = await externalAddress.toAddressPoint();
@@ -139,3 +135,13 @@ export async function computeTaggingSecretPoint(
   // computeAddressSecret takes care of selecting the one that leads to a positive y-coordinate, which is the only valid address point
   return curve.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, ivsk));
 }
+
+export async function computeAppTaggingSecret(
+  knownAddress: CompleteAddress,
+  ivsk: Fq,
+  externalAddress: AztecAddress,
+  app: AztecAddress,
+) {
+  const taggingSecretPoint = await computeTaggingSecretPoint(knownAddress, ivsk, externalAddress);
+  return poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
+}

package/src/logs/index.ts

@@ -3,9 +3,10 @@ export * from './indexed_tagging_secret.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
+export * from './pending_tagged_log.js';
 export * from './log_id.js';
 export * from './log_filter.js';
 export * from './extended_public_log.js';
 export * from './extended_contract_class_log.js';
-export * from './l1_payload/index.js';
+export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';