@aztec/foundation 0.70.0 → 0.72.1

package/src/abi/encoder.ts

@@ -1,6 +1,7 @@
 import { Fr } from '../fields/index.js';
 import { type AbiType, type FunctionAbi } from './abi.js';
-import { isAddressStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from './utils.js';
+import { U128 } from './u128.js';
+import { isAddressStruct, isFunctionSelectorStruct, isU128Struct, isWrappedFieldStruct } from './utils.js';
 
 /**
  * Encodes arguments for a function call.
@@ -105,6 +106,15 @@ class ArgumentEncoder {
           this.encodeArgument({ kind: 'integer', sign: 'unsigned', width: 32 }, arg.value ?? arg, `${name}.inner`);
           break;
         }
+        if (isU128Struct(abiType)) {
+          // U128 struct has low and high limbs - so we first convert the value to the 2 limbs and then we encode them
+          const value = new U128(arg);
+          const limbs = value.toFields();
+          const limbNames = U128.getLimbNames();
+          this.encodeArgument({ kind: 'field' }, limbs[0], `${name}.${limbNames[0]}`);
+          this.encodeArgument({ kind: 'field' }, limbs[1], `${name}.${limbNames[1]}`);
+          break;
+        }
         if (isWrappedFieldStruct(abiType)) {
           this.encodeArgument({ kind: 'field' }, arg.inner ?? arg, `${name}.inner`);
           break;

package/src/abi/event_selector.ts

@@ -53,11 +53,10 @@ export class EventSelector extends Selector {
 
   /**
    * Create a Selector instance from a hex-encoded string.
-   * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
-   * Throws an error if the input length is invalid or address value is out of range.
    *
    * @param selector - The hex-encoded string representing the Selector.
    * @returns An Selector instance.
+   * @throws If the selector length is invalid.
    */
   static fromString(selector: string) {
     const buf = fromHex(selector);

package/src/abi/function_selector.ts

@@ -82,11 +82,10 @@ export class FunctionSelector extends Selector {
 
   /**
    * Create a Selector instance from a hex-encoded string.
-   * The input 'address' should be prefixed with '0x' or not, and have exactly 64 hex characters.
-   * Throws an error if the input length is invalid or address value is out of range.
    *
    * @param selector - The hex-encoded string representing the Selector.
    * @returns An Selector instance.
+   * @throws If the selector length is invalid.
    */
   static fromString(selector: string) {
     const buf = fromHex(selector);

package/src/abi/index.ts

@@ -6,3 +6,4 @@ export * from './event_selector.js';
 export * from './function_selector.js';
 export * from './note_selector.js';
 export * from './utils.js';
+export * from './u128.js';

package/src/abi/u128.ts

@@ -0,0 +1,71 @@
+import { Fr } from '../fields/fields.js';
+
+// A typescript version of noir::std::U128
+export class U128 {
+  private readonly value: bigint;
+
+  constructor(value: bigint | number) {
+    if (typeof value === 'number') {
+      value = BigInt(value);
+    }
+
+    // Check value is within 128 bits
+    if (value < 0n || value >= 2n ** 128n) {
+      throw new Error(`Value ${value} is not within 128 bits and hence cannot be converted to U128.`);
+    }
+
+    this.value = value;
+  }
+
+  static fromU64sLE(lo: bigint, hi: bigint): U128 {
+    // Validate limbs are within valid ranges
+    if (lo < 0n || lo >= 2n ** 64n) {
+      throw new Error(`Lower limb ${lo} is not within valid range (0 to 2^64-1)`);
+    }
+    if (hi < 0n || hi >= 2n ** 64n) {
+      throw new Error(`Higher limb ${hi} is not within valid range (0 to 2^64-1)`);
+    }
+
+    // Combine limbs into full value and create new instance
+    const value = (hi << 64n) | lo;
+    return new U128(value);
+  }
+
+  get lo(): bigint {
+    return this.value & 0xffffffffffffffffn;
+  }
+
+  get hi(): bigint {
+    return this.value >> 64n;
+  }
+
+  toInteger(): bigint {
+    return this.value;
+  }
+
+  // We use little-endian ordering to match the order in which U128 defines its limbs.
+  // This is necessary because of how Noir handles serialization:
+  // - When calling a contract function from TypeScript, the serialization below gets used and then Noir
+  //   deserializes using its intrinsic serialization logic (based on the limb order in the struct).
+  // - When calling a contract function from another function, the `serialize` method is invoked
+  //   on the type first.
+  // For this reason if we didn't use the ordering of U128 limbs here and in the implementation of Serialize
+  // trait for U128 we would get an arguments hash mismatch.
+  toFields(): Fr[] {
+    return [new Fr(this.lo), new Fr(this.hi)];
+  }
+
+  // Has to follow ordering of `toFields()`
+  static fromFields(fields: Fr[]): U128 {
+    if (fields.length !== 2) {
+      throw new Error(`Expected 2 fields for U128, got ${fields.length}`);
+    }
+
+    return U128.fromU64sLE(fields[0].toBigInt(), fields[1].toBigInt());
+  }
+
+  // Has to follow ordering of `toFields()`
+  static getLimbNames(): string[] {
+    return ['lo', 'hi'];
+  }
+}

package/src/abi/utils.ts

@@ -36,6 +36,14 @@ export function isFunctionSelectorStruct(abiType: AbiType) {
   return abiType.kind === 'struct' && abiType.path.endsWith('types::abis::function_selector::FunctionSelector');
 }
 
+/**
+ * Returns whether the ABI type is the U128 defined in noir::std.
+ * @param abiType - Type to check.
+ */
+export function isU128Struct(abiType: AbiType) {
+  return abiType.kind === 'struct' && abiType.path.endsWith('U128');
+}
+
 /**
  * Returns whether the ABI type is a struct with a single `inner` field.
  * @param abiType - Type to check.

package/src/array/array.ts

@@ -27,6 +27,21 @@ export function makeTuple<T, N extends number>(length: N, fn: (i: number) => T,
   return Array.from({ length }, (_: any, i: number) => fn(i + offset)) as Tuple<T, N>;
 }
 
+/**
+ * Create an array over an integer range, filled with a function 'fn'.
+ * This is used over e.g. lodash because it resolved to a tuple type, needed for our fixed array type safety.
+ * @param n - The number of integers.
+ * @param fn - The generator function.
+ * @returns The array of numbers.
+ */
+export async function makeTupleAsync<T, N extends number>(length: N, fn: (i: number) => Promise<T>, offset = 0) {
+  return (await Promise.all(
+    Array(length)
+      .fill(0)
+      .map(async (_: any, i: number) => await fn(i + offset)),
+  )) as Tuple<T, N>;
+}
+
 /**
  * Create an array over an integer range, filled with a function 'fn'. However, the latter half of the array are set to zeros.
  * see `makeTuple` above.

package/src/aztec-address/index.ts

@@ -75,11 +75,11 @@ export class AztecAddress {
   /**
    * @returns a random valid address (i.e. one that can be encrypted to).
    */
-  static random() {
+  static async random() {
     // About half of random field elements result in invalid addresses, so we loop until we get a valid one.
     while (true) {
       const candidate = new AztecAddress(Fr.random());
-      if (candidate.isValid()) {
+      if (await candidate.isValid()) {
         return candidate;
       }
     }
@@ -100,20 +100,20 @@ export class AztecAddress {
   /**
    * @returns true if the address is valid. Invalid addresses cannot receive encrypted messages.
    */
-  isValid() {
+  async isValid() {
     // An address is a field value (Fr), which for some purposes is assumed to be the x coordinate of a point in the
     // Grumpkin curve (notably in order to encrypt to it). An address that is not the x coordinate of such a point is
     // called an 'invalid' address.
     //
     // For Grumpkin, y^2 = x^3 − 17 . There exist values x ∈ Fr for which no y satisfies this equation. This means that
     // given such an x and t = x^3 − 17, then sqrt(t) does not exist in Fr.
-    return Point.YFromX(this.xCoord) !== null;
+    return (await Point.YFromX(this.xCoord)) !== null;
   }
 
   /**
    * @returns the Point from which the address is derived. Throws if the address is invalid.
    */
-  toAddressPoint() {
+  toAddressPoint(): Promise<Point> {
     return Point.fromXAndSign(this.xCoord, true);
   }
 

package/src/collection/array.ts

@@ -89,6 +89,21 @@ export async function timesAsync<T>(n: number, fn: (i: number) => Promise<T>): P
   return results;
 }
 
+/**
+ * Executes the given async function n times in parallel and returns the results in an array.
+ * @param n - How many times to repeat.
+ * @param fn - Mapper from index to value.
+ * @returns The array with the result from all executions.
+ */
+export async function timesParallel<T>(n: number, fn: (i: number) => Promise<T>): Promise<T[]> {
+  const results: T[] = await Promise.all(
+    Array(n)
+      .fill(0)
+      .map((_, i) => fn(i)),
+  );
+  return results;
+}
+
 /**
  * Returns the serialized size of all non-empty items in an array.
  * @param arr - Array

package/src/config/env_var.ts

@@ -42,7 +42,6 @@ export type EnvVar =
   | 'DEBUG'
   | 'DEPLOY_AZTEC_CONTRACTS_SALT'
   | 'DEPLOY_AZTEC_CONTRACTS'
-  | 'ENABLE_GAS'
   | 'ENFORCE_FEES'
   | 'ETHEREUM_HOST'
   | 'FEE_JUICE_CONTRACT_ADDRESS'
@@ -70,6 +69,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'
@@ -100,6 +100,7 @@ export type EnvVar =
   | 'P2P_TX_PROTOCOL'
   | 'P2P_UDP_ANNOUNCE_ADDR'
   | 'P2P_UDP_LISTEN_ADDR'
+  | 'P2P_ARCHIVED_TX_LIMIT'
   | 'PEER_ID_PRIVATE_KEY'
   | 'PROVER_BLOB_SINK_URL'
   | 'PROOF_VERIFIER_L1_START_BLOCK'
@@ -116,6 +117,7 @@ export type EnvVar =
   | 'PROVER_BROKER_JOB_MAX_RETRIES'
   | 'PROVER_COORDINATION_NODE_URL'
   | 'PROVER_DISABLED'
+  | 'PROVER_FAILED_PROOF_STORE'
   | 'PROVER_ID'
   | 'PROVER_JOB_POLL_INTERVAL_MS'
   | 'PROVER_JOB_TIMEOUT_MS'
@@ -160,7 +162,6 @@ export type EnvVar =
   | 'TX_GOSSIP_VERSION'
   | 'TXE_PORT'
   | 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS'
-  | 'VALIDATOR_ATTESTATIONS_WAIT_TIMEOUT_MS'
   | 'VALIDATOR_DISABLED'
   | 'VALIDATOR_PRIVATE_KEY'
   | 'VALIDATOR_REEXECUTE'

package/src/config/index.ts

@@ -1,6 +1,6 @@
 import { type EnvVar } from './env_var.js';
 
-export { EnvVar } from './env_var.js';
+export { type EnvVar } from './env_var.js';
 
 export interface ConfigMapping {
   env?: EnvVar;
@@ -102,7 +102,7 @@ export function optionalNumberConfigHelper(): Pick<ConfigMapping, 'parseEnv'> {
 export function booleanConfigHelper(
   defaultVal = false,
 ): Required<Pick<ConfigMapping, 'parseEnv' | 'defaultValue' | 'isBoolean'> & { parseVal: (val: string) => boolean }> {
-  const parse = (val: string | boolean) => (typeof val === 'boolean' ? val : ['1', 'true', 'TRUE'].includes(val));
+  const parse = (val: string | boolean) => (typeof val === 'boolean' ? val : parseBooleanEnv(val));
   return {
     parseEnv: parse,
     parseVal: parse,
@@ -111,6 +111,11 @@ export function booleanConfigHelper(
   };
 }
 
+/** Parses an env var as boolean. Returns true only if value is 1, true, or TRUE. */
+export function parseBooleanEnv(val: string | undefined): boolean {
+  return val !== undefined && ['1', 'true', 'TRUE'].includes(val);
+}
+
 /**
  * Safely parses a number from a string.
  * If the value is not a number or is not a safe integer, the default value is returned.

package/src/fields/fields.ts

@@ -1,4 +1,4 @@
-import { BarretenbergSync } from '@aztec/bb.js';
+import { BarretenbergLazy } from '@aztec/bb.js';
 
 import { inspect } from 'util';
 
@@ -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 BarretenbergLazy.getSingleton()).getWasm();
+    const [buf] = await 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/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,7 +40,6 @@ export function createSafeJsonRpcClient<T extends object>(
     if ([null, undefined, 'null', 'undefined'].includes(res.result)) {
       return;
     }
-
     return (schema as ApiSchema)[methodName].returnType().parse(res.result);
   };
 

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -1,6 +1,6 @@
 import cors from '@koa/cors';
 import http from 'http';
-import Koa from 'koa';
+import { type default as Application, default as Koa } from 'koa';
 import bodyParser from 'koa-bodyparser';
 import compress from 'koa-compress';
 import Router from 'koa-router';
@@ -14,6 +14,15 @@ import { type ApiSchema, type ApiSchemaFor, parseWithOptionals, schemaHasMethod
 import { jsonStringify } from '../convert.js';
 import { assert } from '../js_utils.js';
 
+export type DiagnosticsData = {
+  id: number | string | null;
+  method: string;
+  params: any[];
+  headers: http.IncomingHttpHeaders;
+};
+
+export type DiagnosticsMiddleware = (ctx: DiagnosticsData, next: () => Promise<void>) => Promise<void>;
+
 export class SafeJsonRpcServer {
   /**
    * The HTTP server accepting remote requests.
@@ -31,6 +40,8 @@ export class SafeJsonRpcServer {
     private http200OnError = false,
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
+    /** Additional middlewares */
+    private extraMiddlewares: Application.Middleware[] = [],
     /** Logger */
     private log = createLogger('json-rpc:server'),
   ) {}
@@ -90,8 +101,11 @@ export class SafeJsonRpcServer {
       this.log.error(`Error on API handler: ${error}`);
     });
 
-    app.use(compress({ br: false } as any));
+    app.use(compress({ br: false }));
     app.use(jsonResponse);
+    for (const middleware of this.extraMiddlewares) {
+      app.use(middleware);
+    }
     app.use(exceptionHandler);
     app.use(bodyParser({ jsonLimit: '50mb', enableTypes: ['json'], detectJSON: () => true }));
     app.use(cors());
@@ -114,7 +128,9 @@ export class SafeJsonRpcServer {
       // Fail if not a registered function in the proxy
       if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
         ctx.status = 400;
-        ctx.body = { jsonrpc, id, error: { code: -32601, message: `Method not found: ${method}` } };
+        const code = -32601;
+        const message = `Method not found: ${method}`;
+        ctx.body = { jsonrpc, id, error: { code, message } };
       } else {
         ctx.status = 200;
         const result = await this.proxy.call(method, params);
@@ -263,10 +279,11 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Lo
   };
 }
 
-type SafeJsonRpcServerOptions = {
+export type SafeJsonRpcServerOptions = {
   http200OnError: boolean;
   healthCheck?: StatusCheckFn;
   log?: Logger;
+  middlewares?: Application.Middleware[];
 };
 
 /**
@@ -276,25 +293,24 @@ type SafeJsonRpcServerOptions = {
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
-  options: Omit<SafeJsonRpcServerOptions, 'healthcheck'> = {
-    http200OnError: false,
+  options: Partial<Omit<SafeJsonRpcServerOptions, 'healthcheck'>> = {
     log: createLogger('json-rpc:server'),
   },
 ): SafeJsonRpcServer {
-  const { http200OnError, log } = options;
+  const { middlewares, http200OnError, log } = options;
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);
-  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, log);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, middlewares, log);
 }
 
 export function createSafeJsonRpcServer<T extends object = any>(
   handler: T,
   schema: ApiSchemaFor<T>,
-  options: SafeJsonRpcServerOptions = { http200OnError: false },
+  options: Partial<SafeJsonRpcServerOptions> = {},
 ) {
-  const { http200OnError, log, healthCheck } = options;
+  const { http200OnError, log, healthCheck, middlewares: extraMiddlewares } = options;
   const proxy = new SafeJsonProxy(handler, schema);
-  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, log);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, extraMiddlewares, log);
 }
 
 /**

package/src/log/gcloud-logger-config.ts

@@ -0,0 +1,71 @@
+import { type pino } from 'pino';
+
+/* eslint-disable camelcase */
+
+const GOOGLE_CLOUD_TRACE_ID = 'logging.googleapis.com/trace';
+const GOOGLE_CLOUD_SPAN_ID = 'logging.googleapis.com/spanId';
+const GOOGLE_CLOUD_TRACE_SAMPLED = 'logging.googleapis.com/trace_sampled';
+
+/**
+ * Pino configuration for google cloud observability. Tweaks message and timestamp,
+ * adds trace context attributes, and injects severity level.
+ * Adapted from https://cloud.google.com/trace/docs/setup/nodejs-ot#config-structured-logging.
+ */
+export const GoogleCloudLoggerConfig = {
+  messageKey: 'message',
+  // Same as pino.stdTimeFunctions.isoTime but uses "timestamp" key instead of "time"
+  timestamp(): string {
+    return `,"timestamp":"${new Date(Date.now()).toISOString()}"`;
+  },
+  formatters: {
+    log(object: Record<string, unknown>): Record<string, unknown> {
+      // Add trace context attributes following Cloud Logging structured log format described
+      // in https://cloud.google.com/logging/docs/structured-logging#special-payload-fields
+      const { trace_id, span_id, trace_flags, ...rest } = object;
+
+      if (trace_id && span_id) {
+        return {
+          [GOOGLE_CLOUD_TRACE_ID]: trace_id,
+          [GOOGLE_CLOUD_SPAN_ID]: span_id,
+          [GOOGLE_CLOUD_TRACE_SAMPLED]: trace_flags ? trace_flags === '01' : undefined,
+          trace_flags, // Keep the original trace_flags for otel-pino-stream
+          ...rest,
+        };
+      }
+      return object;
+    },
+    level(label: string, level: number): object {
+      // Inspired by https://github.com/pinojs/pino/issues/726#issuecomment-605814879
+      // Severity labels https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+      let severity: string;
+
+      switch (label as pino.Level | keyof typeof customLevels) {
+        case 'trace':
+        case 'debug':
+          severity = 'DEBUG';
+          break;
+        case 'verbose':
+        case 'info':
+          severity = 'INFO';
+          break;
+        case 'warn':
+          severity = 'WARNING';
+          break;
+        case 'error':
+          severity = 'ERROR';
+          break;
+        case 'fatal':
+          severity = 'CRITICAL';
+          break;
+        default:
+          severity = 'DEFAULT';
+          break;
+      }
+
+      return { severity, level };
+    },
+  },
+} satisfies pino.LoggerOptions;
+
+// Define custom logging levels for pino. Duplicate from pino-logger.ts.
+const customLevels = { verbose: 25 };