@aztec/stdlib 0.86.0 → 0.87.0

package/src/abi/encoder.ts

@@ -10,7 +10,10 @@ import { isAddressStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from
 class ArgumentEncoder {
   private flattened: Fr[] = [];
 
-  constructor(private abi: FunctionAbi, private args: any[]) {}
+  constructor(
+    private abi: FunctionAbi,
+    private args: any[],
+  ) {}
 
   static typeSize(abiType: AbiType): number {
     switch (abiType.kind) {
@@ -124,7 +127,7 @@ class ArgumentEncoder {
         }
         break;
       default:
-        throw new Error(`Unsupported type: ${abiType}`);
+        throw new Error(`Unsupported type: ${abiType.kind}`);
     }
   }
 

package/src/avm/avm.ts

@@ -41,7 +41,10 @@ export class AvmContractClassHint {
 }
 
 export class AvmBytecodeCommitmentHint {
-  constructor(public readonly classId: Fr, public readonly commitment: Fr) {}
+  constructor(
+    public readonly classId: Fr,
+    public readonly commitment: Fr,
+  ) {}
 
   static get schema() {
     return z
@@ -159,7 +162,7 @@ type IndexedTreeLeafPreimagesClasses = typeof NullifierLeafPreimage | typeof Pub
 // NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
 // having the type doesn't suffice since TS does type erasure in the end.
 function AvmGetLeafPreimageHintFactory(klass: IndexedTreeLeafPreimagesClasses) {
-  return class AvmGetLeafPreimageHint {
+  return class {
     constructor(
       public readonly hintKey: AppendOnlyTreeSnapshot,
       // params (tree id will be implicit)
@@ -175,7 +178,7 @@ function AvmGetLeafPreimageHintFactory(klass: IndexedTreeLeafPreimagesClasses) {
           index: schemas.BigInt,
           leafPreimage: klass.schema,
         })
-        .transform(({ hintKey, index, leafPreimage }) => new AvmGetLeafPreimageHint(hintKey, index, leafPreimage));
+        .transform(({ hintKey, index, leafPreimage }) => new this(hintKey, index, leafPreimage));
     }
   };
 }
@@ -212,7 +215,7 @@ export class AvmGetLeafValueHint {
 // NOTE: I need this factory because in order to get hold of the schema, I need an actual instance of the class,
 // having the type doesn't suffice since TS does type erasure in the end.
 function AvmSequentialInsertHintFactory(klass: IndexedTreeLeafPreimagesClasses) {
-  return class AvmSequentialInsertHint {
+  return class {
     constructor(
       public readonly hintKey: AppendOnlyTreeSnapshot,
       public readonly stateAfter: AppendOnlyTreeSnapshot,
@@ -252,7 +255,7 @@ function AvmSequentialInsertHintFactory(klass: IndexedTreeLeafPreimagesClasses)
         })
         .transform(
           ({ hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData }) =>
-            new AvmSequentialInsertHint(hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData),
+            new this(hintKey, stateAfter, treeId, leaf, lowLeavesWitnessData, insertionWitnessData),
         );
     }
   };
@@ -306,7 +309,7 @@ class AvmCheckpointActionNoStateChangeHint {
       })
       .transform(
         ({ actionCounter, oldCheckpointId, newCheckpointId }) =>
-          new AvmCheckpointActionNoStateChangeHint(actionCounter, oldCheckpointId, newCheckpointId),
+          new this(actionCounter, oldCheckpointId, newCheckpointId),
       );
   }
 }
@@ -608,7 +611,10 @@ export class AvmExecutionHints {
 }
 
 export class AvmCircuitInputs {
-  constructor(public readonly hints: AvmExecutionHints, public publicInputs: AvmCircuitPublicInputs) {}
+  constructor(
+    public readonly hints: AvmExecutionHints,
+    public publicInputs: AvmCircuitPublicInputs,
+  ) {}
 
   static empty() {
     return new AvmCircuitInputs(AvmExecutionHints.empty(), AvmCircuitPublicInputs.empty());

package/src/avm/avm_accumulated_data.ts

@@ -1,15 +1,23 @@
 import {
+  AVM_ACCUMULATED_DATA_LENGTH,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  assertLength,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
@@ -92,6 +100,16 @@ export class AvmAccumulatedData {
     return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicLogs, this.publicDataWrites);
   }
 
+  static getFields(fields: FieldsOf<AvmAccumulatedData>) {
+    return [
+      fields.noteHashes,
+      fields.nullifiers,
+      fields.l2ToL1Msgs,
+      fields.publicLogs,
+      fields.publicDataWrites,
+    ] as const;
+  }
+
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new this(
@@ -103,6 +121,16 @@ export class AvmAccumulatedData {
     );
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...AvmAccumulatedData.getFields(this));
+    if (fields.length !== AVM_ACCUMULATED_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for AvmAccumulatedData. Expected ${AVM_ACCUMULATED_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
   static fromString(str: string) {
     return this.fromBuffer(hexToBuffer(str));
   }

package/src/avm/avm_circuit_public_inputs.ts

@@ -24,6 +24,8 @@ import { serializeWithMessagePack } from './message_pack.js';
 // At some point it might be worth writing Zod schemas for all dependent types and get rid of that.
 export class AvmCircuitPublicInputs {
   constructor(
+    ///////////////////////////////////
+    // Inputs.
     public globalVariables: GlobalVariables,
     public startTreeSnapshots: TreeSnapshots,
     public startGasUsed: Gas,
@@ -36,6 +38,8 @@ export class AvmCircuitPublicInputs {
     public previousRevertibleAccumulatedDataArrayLengths: PrivateToAvmAccumulatedDataArrayLengths,
     public previousNonRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
     public previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData,
+    ///////////////////////////////////
+    // Outputs.
     public endTreeSnapshots: TreeSnapshots,
     public endGasUsed: Gas,
     public accumulatedData: AvmAccumulatedData,
@@ -182,6 +186,28 @@ export class AvmCircuitPublicInputs {
     );
   }
 
+  toFields() {
+    return [
+      ...this.globalVariables.toFields(),
+      ...this.startTreeSnapshots.toFields(),
+      ...this.startGasUsed.toFields(),
+      ...this.gasSettings.toFields(),
+      this.feePayer,
+      ...this.publicSetupCallRequests.map(request => request.toFields()),
+      ...this.publicAppLogicCallRequests.map(request => request.toFields()),
+      ...this.publicTeardownCallRequest.toFields(),
+      ...this.previousNonRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousRevertibleAccumulatedDataArrayLengths.toFields(),
+      ...this.previousNonRevertibleAccumulatedData.toFields(),
+      ...this.previousRevertibleAccumulatedData.toFields(),
+      ...this.endTreeSnapshots.toFields(),
+      ...this.endGasUsed.toFields(),
+      ...this.accumulatedData.toFields(),
+      this.transactionFee,
+      this.reverted,
+    ];
+  }
+
   static empty() {
     return new AvmCircuitPublicInputs(
       GlobalVariables.empty(),

package/src/avm/message_pack.ts

@@ -1,3 +1,4 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fq, Fr, Point } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
@@ -30,7 +31,7 @@ function setUpMessagePackExtensions() {
     Class: Fq,
     write: (fq: Fq) => fq.toBuffer(),
   });
-  // AztecAddress is a class that has a field in TS, but just a field in C++.
+  // AztecAddress is a class that has a field in TS, but is itself a field in C++.
   addExtension({
     Class: AztecAddress,
     write: (addr: AztecAddress) => addr.toField(),
@@ -44,5 +45,10 @@ function setUpMessagePackExtensions() {
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
   });
+  // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.
+  addExtension({
+    Class: EthAddress,
+    write: (addr: EthAddress) => addr.toField().toBuffer(),
+  });
   messagePackWasSetUp = true;
 }

package/src/avm/public_data_write.ts

@@ -1,6 +1,7 @@
+import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -45,6 +46,25 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PublicDataWrite.getFields(this));
+    if (fields.length !== PUBLIC_DATA_WRITE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PublicDataWrite. Expected ${PUBLIC_DATA_WRITE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PublicDataWrite(reader.readField(), reader.readField());
+  }
+
+  toBlobFields(): Fr[] {
+    return [this.leafSlot, this.value];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataWrite(Fr.fromBuffer(reader), Fr.fromBuffer(reader));

package/src/avm/public_inner_call_request.ts

@@ -78,7 +78,7 @@ export class PublicInnerCallRequest {
 
   [inspect.custom]() {
     return `PublicInnerCallRequest {
-      item: ${this.item}
+      item: ${this.item.toFields()}
       counter: ${this.counter}
     }`;
   }

package/src/avm/revert_code.ts

@@ -13,10 +13,10 @@ export enum RevertCodeEnum {
 
 function isRevertCodeEnum(value: number): value is RevertCodeEnum {
   return (
-    value === RevertCodeEnum.OK ||
-    value === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    value === RevertCodeEnum.TEARDOWN_REVERTED ||
-    value === RevertCodeEnum.BOTH_REVERTED
+    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
+    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
   );
 }
 
@@ -46,7 +46,7 @@ export class RevertCode {
   }
 
   public getDescription() {
-    switch (this.code) {
+    switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
       case RevertCodeEnum.APP_LOGIC_REVERTED:

package/src/block/body.ts

@@ -1,7 +1,7 @@
 import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
 import { timesParallel } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -73,17 +73,11 @@ export class Body {
    * Decodes a block from blob fields.
    */
   static fromBlobFields(fields: Fr[]) {
-    const txEffectsFields: Fr[][] = [];
-    let checkedFields = 0;
-    while (checkedFields !== fields.length) {
-      if (!TxEffect.isFirstField(fields[checkedFields])) {
-        throw new Error('Invalid fields given to Body.fromBlobFields(): First field invalid.');
-      }
-      const len = TxEffect.decodeFirstField(fields[checkedFields]).length;
-      txEffectsFields.push(fields.slice(checkedFields, checkedFields + len));
-      checkedFields += len;
+    const txEffects: TxEffect[] = [];
+    const reader = new FieldReader(fields);
+    while (!reader.isFinished()) {
+      txEffects.push(TxEffect.fromBlobFields(reader));
     }
-    const txEffects = txEffectsFields.filter(effect => effect.length).map(effect => TxEffect.fromBlobFields(effect));
     return new this(txEffects);
   }
 

package/src/block/l2_block.ts

@@ -1,4 +1,3 @@
-import { sha256, sha256ToField } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -117,65 +116,6 @@ export class L2Block {
     return this.header.hash();
   }
 
-  /**
-   * Computes the public inputs hash for the L2 block.
-   * The same output as the hash of RootRollupPublicInputs.
-   * TODO(Miranda): Check where/if this is used (v diff now with epochs and blobs)
-   * @returns The public input hash for the L2 block as a field element.
-   */
-  // TODO(#4844)
-  getPublicInputsHash(): Fr {
-    const preimage = [
-      this.header.globalVariables,
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot / commitments,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    ];
-
-    return sha256ToField(preimage);
-  }
-
-  /**
-   * Computes the start state hash (should equal contract data before block).
-   * @returns The start state hash for the L2 block.
-   */
-  // TODO(#4844)
-  getStartStateHash() {
-    const inputValue = serializeToBuffer(
-      new Fr(Number(this.header.globalVariables.blockNumber.toBigInt()) - 1),
-      AppendOnlyTreeSnapshot.zero(), // this.startNoteHashTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startNullifierTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startPublicDataTreeSnapshot,
-      AppendOnlyTreeSnapshot.zero(), // this.startL1ToL2MessageTreeSnapshot,
-      this.header.lastArchive,
-    );
-    return sha256(inputValue);
-  }
-
-  /**
-   * Computes the end state hash (should equal contract data after block).
-   * @returns The end state hash for the L2 block.
-   */
-  // TODO(#4844)
-  getEndStateHash() {
-    const inputValue = serializeToBuffer(
-      this.header.globalVariables.blockNumber,
-      this.header.state.partial.noteHashTree,
-      this.header.state.partial.nullifierTree,
-      this.header.state.partial.publicDataTree,
-      this.header.state.l1ToL2MessageTree,
-      this.archive,
-    );
-    return sha256(inputValue);
-  }
-
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.
@@ -190,7 +130,7 @@ export class L2Block {
       ),
       contractClassLogSize: this.body.txEffects.reduce(
         (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((logSize, log) => logSize + log.getEmittedLength(), 0),
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
         0,
       ),
     };

package/src/block/published_l2_block.ts

@@ -1,12 +1,12 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { times } from '@aztec/foundation/collection';
-import { Secp256k1Signer } from '@aztec/foundation/crypto';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { schemas } from '@aztec/foundation/schemas';
 import { L2Block } from '@aztec/stdlib/block';
 
 import { z } from 'zod';
 
+import { BlockAttestation } from '../p2p/block_attestation.js';
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+
 export type L1PublishedData = {
   blockNumber: bigint;
   timestamp: bigint;
@@ -29,17 +29,9 @@ export const PublishedL2BlockSchema = z.object({
   signatures: z.array(Signature.schema),
 });
 
-export async function randomPublishedL2Block(l2BlockNumber: number): Promise<PublishedL2Block> {
-  const block = await L2Block.random(l2BlockNumber);
-  const l1 = {
-    blockNumber: BigInt(block.number),
-    timestamp: block.header.globalVariables.timestamp.toBigInt(),
-    blockHash: Buffer32.random().toString(),
-  };
-  // Create valid signatures
-  const signers = times(3, () => Secp256k1Signer.random());
-  const signatures = await Promise.all(
-    times(3, async i => signers[i].signMessage(Buffer32.fromField(await block.hash()))),
-  );
-  return { block, l1, signatures };
+export function getAttestationsFromPublishedL2Block(block: PublishedL2Block) {
+  const payload = ConsensusPayload.fromBlock(block.block);
+  return block.signatures
+    .filter(sig => !sig.isEmpty)
+    .map(signature => new BlockAttestation(block.block.header.globalVariables.blockNumber, payload, signature));
 }

package/src/config/index.ts

@@ -1 +1,2 @@
-export * from './config.js';
+export * from './chain-config.js';
+export * from './node-rpc-config.js';

package/src/config/node-rpc-config.ts

@@ -0,0 +1,14 @@
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+
+export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
+  rpcSimulatePublicMaxGasLimit: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT',
+    description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
+    ...numberConfigHelper(10e9),
+  },
+};
+
+export type NodeRPCConfig = {
+  /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxGasLimit: number;
+};

package/src/contract/artifact_hash.ts

@@ -4,6 +4,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { numToUInt8 } from '@aztec/foundation/serialize';
 import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
 
+import deterministicStringify from 'json-stringify-deterministic';
+
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 
 const VERSION = 1;
@@ -58,7 +60,7 @@ export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
 }
 
 export function computeArtifactMetadataHash(artifact: ContractArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
+  return sha256Fr(Buffer.from(deterministicStringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
 }
 
 export async function computeArtifactFunctionTreeRoot(artifact: ContractArtifact, fnType: FunctionType) {
@@ -103,7 +105,7 @@ export async function computeFunctionArtifactHash(
 }
 
 export function computeFunctionMetadataHash(fn: FunctionArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify(fn.returnTypes), 'utf8'));
+  return sha256Fr(Buffer.from(deterministicStringify(fn.returnTypes), 'utf8'));
 }
 
 function getLogger() {
@@ -111,5 +113,5 @@ function getLogger() {
 }
 
 export function getArtifactMerkleTreeHasher() {
-  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer());
+  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer() as Buffer<ArrayBuffer>);
 }

package/src/contract/private_function.ts

@@ -36,11 +36,13 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
-    const functionTreeZeroLeaf = (await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))).toBuffer();
+    const functionTreeZeroLeaf = (
+      await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+    ).toBuffer() as Buffer<ArrayBuffer>;
     privateFunctionTreeCalculator = await MerkleTreeCalculator.create(
       FUNCTION_TREE_HEIGHT,
       functionTreeZeroLeaf,
-      async (left, right) => (await poseidon2Hash([left, right])).toBuffer(),
+      async (left, right) => (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
     );
   }
   return privateFunctionTreeCalculator;

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/file-store/factory.ts

@@ -36,7 +36,7 @@ export async function createFileStore(
       const store = new GoogleCloudFileStore(bucket, path);
       await store.checkCredentials();
       return store;
-    } catch (err) {
+    } catch {
       throw new Error(`Invalid google cloud store definition: '${config}'.`);
     }
   } else {

package/src/file-store/http.ts

@@ -1,6 +1,7 @@
 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';
@@ -10,13 +11,18 @@ import { finished } from 'stream/promises';
 import type { ReadOnlyFileStore } from './interface.js';
 
 export class HttpFileStore implements ReadOnlyFileStore {
-  private readonly fetch: typeof fetch;
+  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.fetch = async (...args: Parameters<typeof fetch>): Promise<Response> => {
+  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(
-        () => fetch(...args),
-        `Fetching ${args[0]}`,
+        () => this.axiosInstance.request<T>(config),
+        `Fetching ${config.url}`,
         makeBackoff([1, 1, 3]),
         this.log,
         /*failSilently=*/ true,
@@ -26,30 +32,33 @@ export class HttpFileStore implements ReadOnlyFileStore {
 
   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}`);
+    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);
-    const response = await this.fetch(url);
-    if (response.ok) {
+    try {
+      const response = await this.fetch<Readable>({ url, method: 'GET', responseType: 'stream' });
       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}`);
+      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);
-    const response = await this.fetch(url);
-    return response.ok;
+    try {
+      await this.fetch<unknown>({ url, method: 'HEAD' });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   private getUrl(path: string): string {

package/src/gas/gas.ts

@@ -14,7 +14,10 @@ export type GasDimensions = (typeof GasDimensions)[number];
 
 /** Gas amounts in each dimension. */
 export class Gas {
-  constructor(public readonly daGas: UInt32, public readonly l2Gas: UInt32) {}
+  constructor(
+    public readonly daGas: UInt32,
+    public readonly l2Gas: UInt32,
+  ) {}
 
   static get schema() {
     return z