@aztec/foundation 0.71.0 → 0.73.0

package/src/config/env_var.ts

@@ -16,6 +16,8 @@ export type EnvVar =
   | 'BB_SKIP_CLEANUP'
   | 'BB_WORKING_DIRECTORY'
   | 'BOOTSTRAP_NODES'
+  | 'BLOB_SINK_PORT'
+  | 'BLOB_SINK_URL'
   | 'BOT_DA_GAS_LIMIT'
   | 'BOT_FEE_PAYMENT_METHOD'
   | 'BOT_FLUSH_SETUP_TRANSACTIONS'
@@ -42,7 +44,6 @@ export type EnvVar =
   | 'DEBUG'
   | 'DEPLOY_AZTEC_CONTRACTS_SALT'
   | 'DEPLOY_AZTEC_CONTRACTS'
-  | 'ENABLE_GAS'
   | 'ENFORCE_FEES'
   | 'ETHEREUM_HOST'
   | 'FEE_JUICE_CONTRACT_ADDRESS'
@@ -52,7 +53,9 @@ export type EnvVar =
   | 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS'
   | 'INBOX_CONTRACT_ADDRESS'
   | 'L1_CHAIN_ID'
-  | 'L1_CONSENSUS_CLIENT_URL'
+  | 'L1_CONSENSUS_HOST_URL'
+  | 'L1_CONSENSUS_HOST_API_KEY'
+  | 'L1_CONSENSUS_HOST_API_KEY_HEADER'
   | 'L1_PRIVATE_KEY'
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
@@ -70,6 +73,7 @@ export type EnvVar =
   | 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'
   | 'OTEL_SERVICE_NAME'
   | 'OTEL_COLLECT_INTERVAL_MS'
+  | 'OTEL_EXCLUDE_METRICS'
   | 'OTEL_EXPORT_TIMEOUT_MS'
   | 'OUTBOX_CONTRACT_ADDRESS'
   | 'P2P_BLOCK_CHECK_INTERVAL_MS'
@@ -102,7 +106,6 @@ export type EnvVar =
   | 'P2P_UDP_LISTEN_ADDR'
   | 'P2P_ARCHIVED_TX_LIMIT'
   | 'PEER_ID_PRIVATE_KEY'
-  | 'PROVER_BLOB_SINK_URL'
   | 'PROOF_VERIFIER_L1_START_BLOCK'
   | 'PROOF_VERIFIER_POLL_INTERVAL_MS'
   | 'PROVER_AGENT_ENABLED'
@@ -142,7 +145,6 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
-  | 'SEQ_BLOB_SINK_URL'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
   | 'SEQ_MAX_TX_PER_BLOCK'
   | 'SEQ_MIN_TX_PER_BLOCK'
@@ -205,4 +207,5 @@ export type EnvVar =
   | 'FAUCET_L1_ASSETS'
   | 'K8S_POD_NAME'
   | 'K8S_POD_UID'
-  | 'K8S_NAMESPACE_NAME';
+  | 'K8S_NAMESPACE_NAME'
+  | 'CUSTOM_FORWARDER_CONTRACT_ADDRESS';

package/src/config/index.ts

@@ -9,6 +9,7 @@ export interface ConfigMapping {
   printDefault?: (val: any) => string;
   description: string;
   isBoolean?: boolean;
+  nested?: Record<string, ConfigMapping>;
 }
 
 export function isBooleanConfigValue<T>(obj: T, key: keyof T): boolean {
@@ -21,18 +22,15 @@ export function getConfigFromMappings<T>(configMappings: ConfigMappingsType<T>):
   const config = {} as T;
 
   for (const key in configMappings) {
-    if (configMappings[key]) {
-      const { env, parseEnv, defaultValue: def } = configMappings[key];
-      // Special case for L1 contract addresses which is an object of config values
-      if (key === 'l1Contracts' && def) {
-        (config as any)[key] = getConfigFromMappings(def);
-      } else {
-        const val = env ? process.env[env] : undefined;
-        if (val !== undefined) {
-          (config as any)[key] = parseEnv ? parseEnv(val) : val;
-        } else if (def !== undefined) {
-          (config as any)[key] = def;
-        }
+    const { env, parseEnv, defaultValue: def, nested } = configMappings[key];
+    if (nested) {
+      (config as any)[key] = getConfigFromMappings(nested);
+    } else {
+      const val = env ? process.env[env] : undefined;
+      if (val !== undefined) {
+        (config as any)[key] = parseEnv ? parseEnv(val) : val;
+      } else if (def !== undefined) {
+        (config as any)[key] = def;
       }
     }
   }

package/src/crypto/index.ts

@@ -1,5 +1,3 @@
-import { BarretenbergSync } from '@aztec/bb.js';
-
 export * from './keccak/index.js';
 export * from './random/index.js';
 export * from './sha256/index.js';
@@ -8,13 +6,3 @@ export * from './pedersen/index.js';
 export * from './poseidon/index.js';
 export * from './secp256k1-signer/index.js';
 export * from './keys/index.js';
-
-/**
- * Init the bb singleton. This constructs (if not already) the barretenberg sync api within bb.js itself.
- * It takes about 100-200ms to initialize. It may not seem like much, but when in conjunction with many other things
- * initializing, developers may want to pick precisely when to incur this cost.
- * If in a test environment, we'll just do it on module load.
- */
-export async function init() {
-  await BarretenbergSync.initSingleton();
-}

package/src/crypto/keys/index.ts

@@ -2,8 +2,9 @@ import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 
-export function vkAsFieldsMegaHonk(input: Buffer): Fr[] {
-  return BarretenbergSync.getSingleton()
-    .acirVkAsFieldsMegaHonk(new RawBuffer(input))
-    .map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
+export async function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]> {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.acirVkAsFieldsMegaHonk(new RawBuffer(input));
+
+  return result.map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
 }

package/src/crypto/pedersen/pedersen.wasm.ts

@@ -7,12 +7,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * Create a pedersen commitment (point) from an array of input fields.
  * Left pads any inputs less than 32 bytes.
  */
-export function pedersenCommit(input: Buffer[], offset = 0) {
+export async function pedersenCommit(input: Buffer[], offset = 0) {
   if (!input.every(i => i.length <= 32)) {
     throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  const point = BarretenbergSync.getSingleton().pedersenCommit(
+  const api = await BarretenbergSync.initSingleton();
+  const point = api.pedersenCommit(
     input.map(i => new FrBarretenberg(i)),
     offset,
   );
@@ -27,23 +28,21 @@ export function pedersenCommit(input: Buffer[], offset = 0) {
  * @param index - The separator index to use for the hash.
  * @returns The pedersen hash.
  */
-export function pedersenHash(input: Fieldable[], index = 0): Fr {
+export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .pedersenHash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-          index,
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
  * Create a pedersen hash from an arbitrary length buffer.
  */
-export function pedersenHashBuffer(input: Buffer, index = 0) {
-  return Buffer.from(BarretenbergSync.getSingleton().pedersenHashBuffer(input, index).toBuffer());
+export async function pedersenHashBuffer(input: Buffer, index = 0) {
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
 }

package/src/crypto/poseidon/index.ts

@@ -8,17 +8,13 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  * @param input - The input fields to hash.
  * @returns The poseidon hash.
  */
-export function poseidon2Hash(input: Fieldable[]): Fr {
+export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const hash = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
 /**
@@ -27,29 +23,22 @@ export function poseidon2Hash(input: Fieldable[]): Fr {
  * @param separator - The domain separator.
  * @returns The poseidon hash.
  */
-export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+export async function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Promise<Fr> {
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+
+  const hash = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
 }
 
-export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+export async function poseidon2HashAccumulate(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())))
-        .toBuffer(),
-    ),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const result = api.poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
 }
 
 /**
@@ -57,19 +46,18 @@ export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
  * @param input the input state. Expected to be of size 4.
  * @returns the output state, size 4.
  */
-export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+export async function poseidon2Permutation(input: Fieldable[]): Promise<Fr[]> {
   const inputFields = serializeToFields(input);
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(input.length === 4, 'Input state must be of size 4');
-  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.poseidon2Permutation(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(res.length === 4, 'Output state must be of size 4');
   return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
 }
 
-export function poseidon2HashBytes(input: Buffer): Fr {
+export async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
   const inputFields = [];
   for (let i = 0; i < input.length; i += 31) {
     const fieldBytes = Buffer.alloc(32, 0);
@@ -80,13 +68,10 @@ export function poseidon2HashBytes(input: Buffer): Fr {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  return Fr.fromBuffer(
-    Buffer.from(
-      BarretenbergSync.getSingleton()
-        .poseidon2Hash(
-          inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-        )
-        .toBuffer(),
-    ),
+  const api = await BarretenbergSync.initSingleton();
+  const res = api.poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
   );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
 }

package/src/crypto/sync/index.ts

@@ -0,0 +1,6 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+
+export * from './poseidon/index.js';
+export * from './pedersen/index.js';
+
+await BarretenbergSync.initSingleton();

package/src/crypto/sync/pedersen/index.ts

@@ -0,0 +1,45 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export function pedersenCommit(input: Buffer[], offset = 0) {
+  if (!input.every(i => i.length <= 32)) {
+    throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
+  }
+  input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
+  const point = BarretenbergSync.getSingleton().pedersenCommit(
+    input.map(i => new FrBarretenberg(i)),
+    offset,
+  );
+  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+  // TODO: rename toTypedArray()?
+  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
+}
+
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */
+export function pedersenHash(input: Fieldable[], index = 0): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().pedersenHash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+    index,
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export function pedersenHashBuffer(input: Buffer, index = 0) {
+  const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
+  return Buffer.from(result.toBuffer());
+}

package/src/crypto/sync/poseidon/index.ts

@@ -0,0 +1,76 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
+
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */
+export function poseidon2Hash(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */
+export function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Fr {
+  const inputFields = serializeToFields(input);
+  inputFields.unshift(new Fr(separator));
+
+  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+
+export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
+  const inputFields = serializeToFields(input);
+  const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+}
+
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */
+export function poseidon2Permutation(input: Fieldable[]): Fr[] {
+  const inputFields = serializeToFields(input);
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(input.length === 4, 'Input state must be of size 4');
+  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
+  );
+  // We'd like this assertion but it's not possible to use it in the browser.
+  // assert(res.length === 4, 'Output state must be of size 4');
+  return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
+}
+
+export function poseidon2HashBytes(input: Buffer): Fr {
+  const inputFields = [];
+  for (let i = 0; i < input.length; i += 31) {
+    const fieldBytes = Buffer.alloc(32, 0);
+    input.slice(i, i + 31).copy(fieldBytes);
+
+    // Noir builds the bytes as little-endian, so we need to reverse them.
+    fieldBytes.reverse();
+    inputFields.push(Fr.fromBuffer(fieldBytes));
+  }
+
+  const res = BarretenbergSync.getSingleton().poseidon2Hash(
+    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
+  );
+
+  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+}

package/src/fields/fields.ts

@@ -99,6 +99,10 @@ abstract class BaseField {
     return Boolean(this.toBigInt());
   }
 
+  /**
+   * Converts this field to a number.
+   * Throws if the underlying value is greater than MAX_SAFE_INTEGER.
+   */
   toNumber(): number {
     const value = this.toBigInt();
     if (value > Number.MAX_SAFE_INTEGER) {
@@ -107,6 +111,15 @@ abstract class BaseField {
     return Number(value);
   }
 
+  /**
+   * Converts this field to a number.
+   * May cause loss of precision if the underlying value is greater than MAX_SAFE_INTEGER.
+   */
+  toNumberUnsafe(): number {
+    const value = this.toBigInt();
+    return Number(value);
+  }
+
   toShortString(): string {
     const str = this.toString();
     return `${str.slice(0, 10)}...${str.slice(-4)}`;
@@ -305,19 +318,15 @@ export class Fr extends BaseField {
    * Computes a square root of the field element.
    * @returns A square root of the field element (null if it does not exist).
    */
-  sqrt(): Fr | null {
-    const wasm = BarretenbergSync.getSingleton().getWasm();
-    wasm.writeMemory(0, this.toBuffer());
-    wasm.call('bn254_fr_sqrt', 0, Fr.SIZE_IN_BYTES);
-    const isSqrtBuf = Buffer.from(wasm.getMemorySlice(Fr.SIZE_IN_BYTES, Fr.SIZE_IN_BYTES + 1));
-    const isSqrt = isSqrtBuf[0] === 1;
+  async sqrt(): Promise<Fr | null> {
+    const wasm = (await BarretenbergSync.initSingleton()).getWasm();
+    const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
+    const isSqrt = buf[0] === 1;
     if (!isSqrt) {
       // Field element is not a quadratic residue mod p so it has no square root.
       return null;
     }
-
-    const rootBuf = Buffer.from(wasm.getMemorySlice(Fr.SIZE_IN_BYTES + 1, Fr.SIZE_IN_BYTES * 2 + 1));
-    return Fr.fromBuffer(rootBuf);
+    return new Fr(Buffer.from(buf.slice(1)));
   }
 
   toJSON() {

package/src/fields/point.ts

@@ -50,10 +50,10 @@ export class Point {
    *
    * @returns A randomly generated Point instance.
    */
-  static random() {
+  static async random() {
     while (true) {
       try {
-        return Point.fromXAndSign(Fr.random(), randomBoolean());
+        return await Point.fromXAndSign(Fr.random(), randomBoolean());
       } catch (e: any) {
         if (!(e instanceof NotOnCurveError)) {
           throw e;
@@ -83,7 +83,7 @@ export class Point {
    * @param buffer - The buffer containing the x coordinate and the sign of the y coordinate.
    * @returns A Point instance.
    */
-  static fromCompressedBuffer(buffer: Buffer | BufferReader) {
+  static fromCompressedBuffer(buffer: Buffer | BufferReader): Promise<Point> {
     const reader = BufferReader.asReader(buffer);
     const value = toBigIntBE(reader.readBytes(Point.COMPRESSED_SIZE_IN_BYTES));
 
@@ -127,8 +127,8 @@ export class Point {
    * Instead it is a boolean flag that determines whether the y coordinate is <= (Fr.MODULUS - 1) / 2
    * @returns The point as an array of 2 fields
    */
-  static fromXAndSign(x: Fr, sign: boolean) {
-    const y = Point.YFromX(x);
+  static async fromXAndSign(x: Fr, sign: boolean) {
+    const y = await Point.YFromX(x);
     if (y == null) {
       throw new NotOnCurveError(x);
     }
@@ -146,7 +146,7 @@ export class Point {
   /**
    * @returns
    */
-  static YFromX(x: Fr): Fr | null {
+  static YFromX(x: Fr): Promise<Fr | null> {
     // Calculate y^2 = x^3 - 17 (i.e. the Grumpkin curve equation)
     const ySquared = x.square().mul(x).sub(new Fr(17));
 

package/src/iterable/toArray.ts

@@ -1,4 +1,6 @@
-export async function toArray<T>(iterator: AsyncIterableIterator<T> | IterableIterator<T>): Promise<T[]> {
+export async function toArray<T>(
+  iterator: Iterable<T> | AsyncIterableIterator<T> | AsyncIterable<T> | IterableIterator<T>,
+): Promise<T[]> {
   const arr = [];
   for await (const i of iterator) {
     arr.push(i);

package/src/json-rpc/client/fetch.ts

@@ -21,6 +21,7 @@ export async function defaultFetch(
   rpcMethod: string,
   body: any,
   useApiEndpoints: boolean,
+  extraHeaders: Record<string, string> = {},
   noRetry = false,
 ) {
   log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
@@ -30,13 +31,13 @@ export async function defaultFetch(
       resp = await fetch(`${host}/${rpcMethod}`, {
         method: 'POST',
         body: jsonStringify(body),
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', ...extraHeaders },
       });
     } else {
       resp = await fetch(host, {
         method: 'POST',
         body: jsonStringify({ ...body, method: rpcMethod }),
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', ...extraHeaders },
       });
     }
   } catch (err) {
@@ -55,7 +56,7 @@ export async function defaultFetch(
   }
 
   if (!resp.ok) {
-    const errorMessage = `(JSON-RPC PROPAGATED) (host ${host}) (method ${rpcMethod}) (code ${resp.status}) ${responseJson.error.message}`;
+    const errorMessage = `Error ${resp.status} from server ${host} on ${rpcMethod}: ${responseJson.error.message}`;
     if (noRetry || (resp.status >= 400 && resp.status < 500)) {
       throw new NoRetryError(errorMessage);
     } else {
@@ -73,10 +74,17 @@ export async function defaultFetch(
  * @param log - Optional logger for logging attempts.
  * @returns A fetch function.
  */
-export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger) {
-  return async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, noRetry?: boolean) => {
+export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger): typeof defaultFetch {
+  return async (
+    host: string,
+    rpcMethod: string,
+    body: any,
+    useApiEndpoints: boolean,
+    extraHeaders: Record<string, string> = {},
+    noRetry?: boolean,
+  ) => {
     return await retry(
-      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, noRetry ?? defaultNoRetry),
+      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, extraHeaders, noRetry ?? defaultNoRetry),
       `JsonRpcClient request ${rpcMethod} to ${host}`,
       makeBackoff(retries),
       log,

package/src/json-rpc/client/safe_json_rpc_client.ts

@@ -40,8 +40,7 @@ export function createSafeJsonRpcClient<T extends object>(
     if ([null, undefined, 'null', 'undefined'].includes(res.result)) {
       return;
     }
-
-    return (schema as ApiSchema)[methodName].returnType().parse(res.result);
+    return (schema as ApiSchema)[methodName].returnType().parseAsync(res.result);
   };
 
   const proxy: any = {};

package/src/json-rpc/convert.ts

@@ -8,8 +8,8 @@ import { type ZodFor } from '../schemas/types.js';
  * @param schema - Zod schema.
  * @returns Result of parsing json with schema.
  */
-export function jsonParseWithSchema<T>(json: string, schema: ZodFor<T>): T {
-  return schema.parse(JSON.parse(json));
+export function jsonParseWithSchema<T>(json: string, schema: ZodFor<T>): Promise<T> {
+  return schema.parseAsync(JSON.parse(json));
 }
 
 /**