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

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

@@ -6,10 +6,13 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 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,32 +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>) {
+  static async readFromTree(delayedPublicMutableSlot: 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))));
+    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
+      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
     }
-    return SharedMutableValues.fromFields(fields);
+    return DelayedPublicMutableValues.fromFields(fields);
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
     const fields = this.toFields();
 
     for (let i = 0; i < fields.length; i++) {
-      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
     }
   }
 

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/fields';
+
+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 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/epoch-helpers/index.ts

@@ -8,6 +8,7 @@ export type L1RollupConstants = {
   slotDuration: number;
   epochDuration: number;
   ethereumSlotDuration: number;
+  proofSubmissionEpochs: number;
 };
 
 export const EmptyL1RollupConstants: L1RollupConstants = {
@@ -16,6 +17,7 @@ export const EmptyL1RollupConstants: L1RollupConstants = {
   epochDuration: 1, // Not 0 to pervent division by zero
   slotDuration: 1,
   ethereumSlotDuration: 1,
+  proofSubmissionEpochs: 1,
 };
 
 export const L1RollupConstantsSchema = z.object({
@@ -24,8 +26,17 @@ export const L1RollupConstantsSchema = z.object({
   slotDuration: z.number(),
   epochDuration: z.number(),
   ethereumSlotDuration: z.number(),
+  proofSubmissionEpochs: 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);
@@ -45,7 +56,10 @@ export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants,
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
-export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
+export function getSlotRangeForEpoch(
+  epochNumber: bigint,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): [bigint, bigint] {
   const startSlot = epochNumber * BigInt(constants.epochDuration);
   return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
 }
@@ -57,7 +71,7 @@ export function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<L1Roll
 export function getTimestampRangeForEpoch(
   epochNumber: bigint,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
-) {
+): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
   const ethereumSlotsPerL2Slot = constants.slotDuration / constants.ethereumSlotDuration;
   return [
@@ -67,3 +81,48 @@ export function getTimestampRangeForEpoch(
       BigInt((ethereumSlotsPerL2Slot - 1) * constants.ethereumSlotDuration),
   ];
 }
+
+/**
+ * Returns the start timestamp for a given epoch number.
+ */
+export function getStartTimestampForEpoch(
+  epochNumber: bigint,
+  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: bigint,
+  constants: Pick<L1RollupConstants, 'proofSubmissionEpochs'>,
+) {
+  return epochNumber + BigInt(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: bigint,
+  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: number | bigint,
+  constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>,
+): number {
+  return Number(constants.l1GenesisTime) + Number(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

@@ -5,7 +5,7 @@ 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 { 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);
+  }
+}

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,67 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+
+import axios, { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse } from 'axios';
+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 axiosInstance: AxiosInstance;
+  private readonly fetch: <T>(config: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+
+  constructor(
+    private readonly baseUrl: string,
+    private readonly log: Logger = createLogger('stdlib:http-file-store'),
+  ) {
+    this.axiosInstance = axios.create();
+    this.fetch = async <T>(config: AxiosRequestConfig) => {
+      return await retry(
+        () => this.axiosInstance.request<T>(config),
+        `Fetching ${config.url}`,
+        makeBackoff([1, 1, 3]),
+        this.log,
+        /*failSilently=*/ true,
+      );
+    };
+  }
+
+  public async read(pathOrUrl: string): Promise<Buffer> {
+    const url = this.getUrl(pathOrUrl);
+    try {
+      const response = await this.fetch<ArrayBuffer>({ url, method: 'GET', responseType: 'arraybuffer' });
+      return Buffer.from(response.data);
+    } catch (error) {
+      throw new Error(`Error fetching file from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public async download(pathOrUrl: string, destPath: string): Promise<void> {
+    const url = this.getUrl(pathOrUrl);
+    try {
+      const response = await this.fetch<Readable>({ url, method: 'GET', responseType: 'stream' });
+      await mkdir(dirname(destPath), { recursive: true });
+      await finished(response.data.pipe(createWriteStream(destPath)));
+    } catch (error) {
+      throw new Error(`Error fetching file from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  public async exists(pathOrUrl: string): Promise<boolean> {
+    const url = this.getUrl(pathOrUrl);
+    try {
+      await this.fetch<unknown>({ url, method: 'HEAD' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  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';