@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/{shared_mutable/shared_mutable_values.ts → delayed_public_mutable/delayed_public_mutable_values.ts}

@@ -1,15 +1,18 @@
 import { UPDATES_VALUE_SIZE } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { ScheduledDelayChange } from './scheduled_delay_change.js';
 import { ScheduledValueChange } from './scheduled_value_change.js';
 
-export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+export const DELAYED_PUBLIC_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
 
-export class SharedMutableValues {
-  constructor(public svc: ScheduledValueChange, public sdc: ScheduledDelayChange) {}
+export class DelayedPublicMutableValues {
+  constructor(
+    public svc: ScheduledValueChange,
+    public sdc: ScheduledDelayChange,
+  ) {}
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
@@ -19,20 +22,20 @@ export class SharedMutableValues {
     // Extract fields for ScheduledValueChange
     const svcPre = reader.readFieldArray(UPDATES_VALUE_SIZE);
     const svcPost = reader.readFieldArray(UPDATES_VALUE_SIZE);
-    const svcBlockOfChange = firstField & 0xffffffffn;
-    const svc = new ScheduledValueChange(svcPre, svcPost, Number(svcBlockOfChange));
+    const svcTimestampOfChange = firstField & 0xffffffffn;
+    const svc = new ScheduledValueChange(svcPre, svcPost, svcTimestampOfChange);
 
     // Extract fields for ScheduledDelayChange from first field
-    const sdcBlockOfChange = (firstField >> 32n) & 0xffffffffn;
+    const sdcTimestampOfChange = (firstField >> 32n) & 0xffffffffn;
     const sdcIsPostSome = (firstField >> 64n) & 1n;
     const sdcPost = (firstField >> 72n) & 0xffffffffn;
     const sdcIsPreSome = (firstField >> 104n) & 1n;
     const sdcPre = (firstField >> 112n) & 0xffffffffn;
 
     const sdc = new ScheduledDelayChange(
-      sdcIsPreSome ? Number(sdcPre) : undefined,
-      sdcIsPostSome ? Number(sdcPost) : undefined,
-      Number(sdcBlockOfChange),
+      sdcIsPreSome ? sdcPre : undefined,
+      sdcIsPostSome ? sdcPost : undefined,
+      sdcTimestampOfChange,
     );
 
     return new this(svc, sdc);
@@ -40,9 +43,9 @@ export class SharedMutableValues {
 
   toFields(): Fr[] {
     // Pack format matches Noir implementation:
-    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.block_of_change: u32 | svc.block_of_change: u32 ]
-    let firstField = BigInt(this.svc.blockOfChange);
-    firstField |= BigInt(this.sdc.blockOfChange) << 32n;
+    // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]
+    let firstField = this.svc.timestampOfChange;
+    firstField |= this.sdc.timestampOfChange << 32n;
     firstField |= (this.sdc.post === undefined ? 0n : 1n) << 64n;
     firstField |= BigInt(this.sdc.post || 0) << 72n;
     firstField |= (this.sdc.pre === undefined ? 0n : 1n) << 104n;
@@ -55,33 +58,32 @@ export class SharedMutableValues {
     return serializeToBuffer(this.toFields());
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): SharedMutableValues {
+  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): DelayedPublicMutableValues {
     const reader = BufferReader.asReader(buffer);
-    return SharedMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+    return DelayedPublicMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
   }
 
   static empty(valueSize: number) {
     return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
   }
 
-  static async readFromTree(sharedMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
-    const fields = [];
-    for (let i = 0; i < SHARED_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(sharedMutableSlot.add(new Fr(i))));
-    }
-    return SharedMutableValues.fromFields(fields);
+  static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
+    const fieldPromises = Array.from({ length: DELAYED_PUBLIC_MUTABLE_VALUES_LEN }).map((_, i) =>
+      readStorage(delayedPublicMutableSlot.add(new Fr(i))),
+    );
+    return DelayedPublicMutableValues.fromFields(await Promise.all(fieldPromises));
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
-    const fields = this.toFields();
+  writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fieldPromises = this.toFields().map((field, i) =>
+      storageWrite(delayedPublicMutableSlot.add(new Fr(i)), field),
+    );
 
-    for (let i = 0; i < fields.length; i++) {
-      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
-    }
+    return Promise.all(fieldPromises);
   }
 
   async hash(): Promise<Fr> {

package/src/delayed_public_mutable/delayed_public_mutable_values_with_hash.ts

@@ -0,0 +1,38 @@
+import { UPDATED_CLASS_IDS_SLOT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { deriveStorageSlotInMap } from '../hash/map_slot.js';
+import { DELAYED_PUBLIC_MUTABLE_VALUES_LEN, DelayedPublicMutableValues } from './delayed_public_mutable_values.js';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+
+export class DelayedPublicMutableValuesWithHash {
+  private dpmv: DelayedPublicMutableValues;
+
+  constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange) {
+    this.dpmv = new DelayedPublicMutableValues(svc, sdc);
+  }
+
+  async toFields(): Promise<Fr[]> {
+    return [...this.dpmv.toFields(), await this.dpmv.hash()];
+  }
+
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = await this.toFields();
+
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
+    }
+  }
+
+  static async getContractUpdateSlots(contractAddress: AztecAddress) {
+    const delayedPublicMutableSlot = await deriveStorageSlotInMap(new Fr(UPDATED_CLASS_IDS_SLOT), contractAddress);
+    const delayedPublicMutableHashSlot = delayedPublicMutableSlot.add(new Fr(DELAYED_PUBLIC_MUTABLE_VALUES_LEN));
+
+    return {
+      delayedPublicMutableSlot,
+      delayedPublicMutableHashSlot,
+    };
+  }
+}

package/src/delayed_public_mutable/index.ts

@@ -0,0 +1,4 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './delayed_public_mutable_values.js';
+export * from './delayed_public_mutable_values_with_hash.js';

package/src/delayed_public_mutable/scheduled_delay_change.ts

@@ -0,0 +1,17 @@
+import type { UInt64 } from '../types/shared.js';
+
+export class ScheduledDelayChange {
+  constructor(
+    public pre: UInt64 | undefined,
+    public post: UInt64 | undefined,
+    public timestampOfChange: UInt64,
+  ) {}
+
+  static empty() {
+    return new this(undefined, undefined, 0n);
+  }
+
+  isEmpty(): boolean {
+    return this.pre === undefined && this.post === undefined && this.timestampOfChange === 0n;
+  }
+}

package/src/{shared_mutable → delayed_public_mutable}/scheduled_value_change.ts

@@ -1,22 +1,28 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { UInt64 } from '../types/shared.js';
 
 export class ScheduledValueChange {
-  constructor(public previous: Fr[], public post: Fr[], public blockOfChange: number) {
+  constructor(
+    public previous: Fr[],
+    public post: Fr[],
+    public timestampOfChange: UInt64,
+  ) {
     if (this.previous.length !== this.post.length) {
       throw new Error('Previous and post must have the same length');
     }
   }
 
   static empty(valueSize: number) {
-    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0);
+    return new this(Array(valueSize).fill(new Fr(0)), Array(valueSize).fill(new Fr(0)), 0n);
   }
 
   isEmpty(): boolean {
-    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.blockOfChange === 0;
+    return this.previous.every(v => v.isZero()) && this.post.every(v => v.isZero()) && this.timestampOfChange === 0n;
   }
 
-  getCurrentAt(blockNumber: number) {
-    if (blockNumber < this.blockOfChange) {
+  getCurrentAt(timestamp: UInt64) {
+    if (timestamp < this.timestampOfChange) {
       return this.previous;
     } else {
       return this.post;

package/src/deserialization/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Constants for deserialization bounds checking.
+ * These constants define maximum allowed sizes during deserialization
+ * to prevent DoS attacks via maliciously crafted messages.
+ */
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+
+/** Max transactions per block for deserialization validation */
+export const MAX_TXS_PER_BLOCK = 2 ** 16;
+
+/** Max committee size - theoretical max from bitmap design (256 bytes × 8 bits) */
+export const MAX_COMMITTEE_SIZE = 2048;
+
+/** Max blocks per checkpoint */
+export const MAX_BLOCKS_PER_CHECKPOINT = 72;
+
+/** Max tx effects per body (based on blob capacity per checkpoint) */
+export const MAX_TX_EFFECTS_PER_BODY = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
+/** Max block hash string length (hex: 0x + 64 chars, with generous headroom) */
+export const MAX_BLOCK_HASH_STRING_LENGTH = 128;

package/src/epoch-helpers/index.ts

@@ -1,6 +1,8 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 
 export type L1RollupConstants = {
   l1StartBlock: bigint;
@@ -8,6 +10,7 @@ export type L1RollupConstants = {
   slotDuration: number;
   epochDuration: number;
   ethereumSlotDuration: number;
+  proofSubmissionEpochs: number;
 };
 
 export const EmptyL1RollupConstants: L1RollupConstants = {
@@ -16,38 +19,58 @@ export const EmptyL1RollupConstants: L1RollupConstants = {
   epochDuration: 1, // Not 0 to pervent division by zero
   slotDuration: 1,
   ethereumSlotDuration: 1,
+  proofSubmissionEpochs: 1,
 };
 
-export const L1RollupConstantsSchema = z.object({
-  l1StartBlock: schemas.BigInt,
-  l1GenesisTime: schemas.BigInt,
-  slotDuration: z.number(),
-  epochDuration: z.number(),
-  ethereumSlotDuration: z.number(),
-}) satisfies ZodFor<L1RollupConstants>;
+export const L1RollupConstantsSchema = zodFor<L1RollupConstants>()(
+  z.object({
+    l1StartBlock: schemas.BigInt,
+    l1GenesisTime: schemas.BigInt,
+    slotDuration: z.number(),
+    epochDuration: z.number(),
+    ethereumSlotDuration: z.number(),
+    proofSubmissionEpochs: z.number(),
+  }),
+);
+
+/** Returns the timestamp for a given L2 slot. */
+export function getTimestampForSlot(
+  slot: SlotNumber,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+) {
+  return constants.l1GenesisTime + BigInt(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);
+export function getSlotAtTimestamp(
+  ts: bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+): SlotNumber {
+  return ts < constants.l1GenesisTime
+    ? SlotNumber.ZERO
+    : SlotNumber.fromBigInt((ts - constants.l1GenesisTime) / BigInt(constants.slotDuration));
 }
 
 /** Returns the epoch number for a given timestamp. */
 export function getEpochNumberAtTimestamp(
   ts: bigint,
   constants: Pick<L1RollupConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>,
-) {
+): EpochNumber {
   return getEpochAtSlot(getSlotAtTimestamp(ts, constants), constants);
 }
 
 /** Returns the epoch number for a given slot. */
-export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
-  return slot / BigInt(constants.epochDuration);
+export function getEpochAtSlot(slot: SlotNumber, constants: Pick<L1RollupConstants, 'epochDuration'>): EpochNumber {
+  return EpochNumber.fromBigInt(BigInt(slot) / BigInt(constants.epochDuration));
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
-export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
-  const startSlot = epochNumber * BigInt(constants.epochDuration);
-  return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
+export function getSlotRangeForEpoch(
+  epochNumber: EpochNumber,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): [SlotNumber, SlotNumber] {
+  const startSlot = SlotNumber(Number(epochNumber) * constants.epochDuration);
+  return [startSlot, SlotNumber(startSlot + constants.epochDuration - 1)];
 }
 
 /**
@@ -55,15 +78,60 @@ export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1Roll
  * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
  */
 export function getTimestampRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
-) {
+): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
-    constants.l1GenesisTime + startSlot * BigInt(constants.slotDuration),
+    constants.l1GenesisTime + BigInt(startSlot) * BigInt(constants.slotDuration),
     constants.l1GenesisTime +
-      endSlot * BigInt(constants.slotDuration) +
+      BigInt(endSlot) * BigInt(constants.slotDuration) +
       BigInt((ethereumSlotsPerL2Slot - 1) * constants.ethereumSlotDuration),
   ];
 }
+
+/**
+ * Returns the start timestamp for a given epoch number.
+ */
+export function getStartTimestampForEpoch(
+  epochNumber: EpochNumber,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
+) {
+  const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
+  return getTimestampForSlot(startSlot, constants);
+}
+
+/**
+ * Returns the epoch number at which proofs are no longer accepted for a given epoch.
+ * See l1-contracts/src/core/libraries/TimeLib.sol
+ */
+export function getProofSubmissionDeadlineEpoch(
+  epochNumber: EpochNumber,
+  constants: Pick<L1RollupConstants, 'proofSubmissionEpochs'>,
+): EpochNumber {
+  return EpochNumber(epochNumber + constants.proofSubmissionEpochs + 1);
+}
+
+/**
+ * Returns the deadline timestamp (in seconds) for submitting a proof for a given epoch.
+ * Computed as the start of the given epoch plus the proof submission window.
+ */
+export function getProofSubmissionDeadlineTimestamp(
+  epochNumber: EpochNumber,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'proofSubmissionEpochs'>,
+) {
+  // See l1-contracts/src/core/libraries/TimeLib.sol:
+  // return toSlots(_a) + Slot.wrap(store.epochDuration * (store.proofSubmissionEpochs + 1));
+  const deadlineEpoch = getProofSubmissionDeadlineEpoch(epochNumber, constants);
+  const [deadlineSlot] = getSlotRangeForEpoch(deadlineEpoch, constants);
+  return getTimestampForSlot(deadlineSlot, constants);
+}
+
+/** Returns the timestamp to start building a block for a given L2 slot. Computed as the start timestamp of the slot minus one L1 slot duration. */
+export function getSlotStartBuildTimestamp(
+  slotNumber: SlotNumber,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
+): number {
+  return Number(constants.l1GenesisTime) + slotNumber * constants.slotDuration - constants.ethereumSlotDuration;
+}

package/src/errors/proving_error.ts

@@ -10,7 +10,11 @@ export class ProvingError extends Error {
    * @param cause - The cause of the error.
    * @param retry - Whether the proof should be retried.
    */
-  constructor(message: string, cause?: unknown, public readonly retry: boolean = false) {
+  constructor(
+    message: string,
+    cause?: unknown,
+    public readonly retry: boolean = false,
+  ) {
     super(message);
     this.name = ProvingError.NAME;
     this.cause = cause;

package/src/errors/simulation_error.ts

@@ -1,11 +1,11 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
 import type { OpcodeLocation } from '../abi/abi.js';
 import { FunctionSelector } from '../abi/function_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { type ZodFor, optional, schemas } from '../schemas/index.js';
 
 /**
  * Address and selector of a function that failed during simulation.
@@ -240,7 +240,7 @@ export class SimulationError extends Error {
           z.object({
             contractAddress: schemas.AztecAddress,
             contractName: z.string().optional(),
-            functionSelector: schemas.FunctionSelector,
+            functionSelector: optional(schemas.FunctionSelector),
             functionName: z.string().optional(),
           }),
         ),

package/src/fees/transaction_fee.ts

@@ -1,21 +1,41 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import { strict as assert } from 'assert';
 
 import type { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import type { GasSettings } from '../gas/gas_settings.js';
 
-export function computeTransactionFee(gasFees: GasFees, gasSettings: GasSettings, gasUsed: Gas): Fr {
+/**
+ * Compute the effective gas fees that should be used to compute the transaction fee.
+ * This is the sum of the gas fees and the priority fees, but capped at the max fees per gas.
+ */
+export function computeEffectiveGasFees(gasFees: GasFees, gasSettings: GasSettings): GasFees {
   const { maxFeesPerGas, maxPriorityFeesPerGas } = gasSettings;
-  const minField = (f1: Fr, f2: Fr) => (f1.lt(f2) ? f1 : f2);
+  const minBigInt = (f1: bigint, f2: bigint) => (f1 < f2 ? f1 : f2);
+
+  assert(
+    maxFeesPerGas.feePerDaGas >= gasFees.feePerDaGas,
+    `maxFeesPerGas.feePerDaGas must be greater than or equal to gasFees.feePerDaGas, but got maxFeesPerGas.feePerDaGas=${maxFeesPerGas.feePerDaGas} and gasFees.feePerDaGas=${gasFees.feePerDaGas}`,
+  );
+  assert(
+    maxFeesPerGas.feePerL2Gas >= gasFees.feePerL2Gas,
+    `maxFeesPerGas.feePerL2Gas must be greater than or equal to gasFees.feePerL2Gas, but got maxFeesPerGas.feePerL2Gas=${maxFeesPerGas.feePerL2Gas} and gasFees.feePerL2Gas=${gasFees.feePerL2Gas}`,
+  );
   const priorityFees = new GasFees(
-    minField(maxPriorityFeesPerGas.feePerDaGas, maxFeesPerGas.feePerDaGas.sub(gasFees.feePerDaGas)),
-    minField(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas.sub(gasFees.feePerL2Gas)),
+    minBigInt(maxPriorityFeesPerGas.feePerDaGas, maxFeesPerGas.feePerDaGas - gasFees.feePerDaGas),
+    minBigInt(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas - gasFees.feePerL2Gas),
   );
 
-  const totalFees = new GasFees(
-    gasFees.feePerDaGas.add(priorityFees.feePerDaGas),
-    gasFees.feePerL2Gas.add(priorityFees.feePerL2Gas),
+  const effectiveFees = new GasFees(
+    gasFees.feePerDaGas + priorityFees.feePerDaGas,
+    gasFees.feePerL2Gas + priorityFees.feePerL2Gas,
   );
 
-  return gasUsed.computeFee(totalFees);
+  return effectiveFees;
+}
+
+export function computeTransactionFee(gasFees: GasFees, gasSettings: GasSettings, gasUsed: Gas): Fr {
+  const effectiveFees = computeEffectiveGasFees(gasFees, gasSettings);
+  return gasUsed.computeFee(effectiveFees);
 }

package/src/file-store/factory.ts

@@ -0,0 +1,76 @@
+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';
+import { S3FileStore } from './s3.js';
+
+const supportedExamples = [
+  `gs://bucket-name/path/to/store`,
+  `s3://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 {
+      throw new Error(`Invalid google cloud store definition: '${config}'.`);
+    }
+  } else if (config.startsWith('s3://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      const endpoint = url.searchParams.get('endpoint');
+      const publicBaseUrl = url.searchParams.get('publicBaseUrl') ?? undefined;
+      logger.info(`Creating S3 file store at ${bucket} ${path}`);
+      const store = new S3FileStore(bucket, path, { endpoint: endpoint ?? undefined, publicBaseUrl });
+      return store;
+    } catch {
+      throw new Error(`Invalid S3 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);
+  }
+}