@aztec/foundation 0.86.0 → 0.87.0

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

@@ -1,27 +1,58 @@
 import { format } from 'util';
 
 import { type Logger, createLogger } from '../../log/pino-logger.js';
+import { type PromiseWithResolvers, promiseWithResolvers } from '../../promise/utils.js';
 import { type ApiSchema, type ApiSchemaFor, schemaHasMethod } from '../../schemas/api.js';
 import { type JsonRpcFetch, defaultFetch } from './fetch.js';
 
+// batch window of 0 would capture all requests in the current sync iteration of the event loop
+// and send them all at once in a single batch
+// minimal latency
+const DEFAULT_BATCH_WINDOW_MS = 0;
+
 export type SafeJsonRpcClientOptions = {
-  useApiEndpoints?: boolean;
   namespaceMethods?: string | false;
   fetch?: JsonRpcFetch;
   log?: Logger;
+  batchWindowMS?: number;
   onResponse?: (res: {
     response: any;
     headers: { get: (header: string) => string | null | undefined };
   }) => Promise<void>;
 };
 
+type JsonRpcRequest = {
+  jsonrpc: '2.0';
+  id?: number;
+  method: string;
+  params?: Array<any>;
+};
+
+type JsonRpcResponse =
+  | {
+      jsonrpc: '2.0';
+      id?: number;
+      result: any;
+    }
+  | {
+      jsonrpc: '2.0';
+      id?: number;
+      error: { code: number; data?: any; message: string };
+    };
+
+// expose helpful information on the RPC clients such that we can recognize them later
+const SEND_BATCH = Symbol('JsonRpcClient.sendBatch');
+const CLIENT_ID = Symbol('JsonRpcClient.clientId');
+
+let nextClientId = 1;
+// keep a reference to clients so that we can force send a batch
+const clients = new Map<number, WeakRef<{ [SEND_BATCH]: () => Promise<void> }>>();
+
 /**
  * Creates a Proxy object that delegates over RPC and validates outputs against a given schema.
  * The server is expected to be a JsonRpcServer.
  * @param host - The host URL.
  * @param schema - The api schema to validate returned data against.
- * @param useApiEndpoints - Whether to use the API endpoints or the default RPC endpoint.
- * @param namespaceMethods - String value (or false/empty) to namespace all methods sent to the server. e.g. 'getInfo' -\> 'pxe_getInfo'
  * @param fetch - The fetch implementation to use.
  */
 export function createSafeJsonRpcClient<T extends object>(
@@ -31,25 +62,118 @@ export function createSafeJsonRpcClient<T extends object>(
 ): T {
   const fetch = config.fetch ?? defaultFetch;
   const log = config.log ?? createLogger('json-rpc:client');
-  const { useApiEndpoints = false, namespaceMethods = false } = config;
+  const { namespaceMethods = false, batchWindowMS = DEFAULT_BATCH_WINDOW_MS } = config;
 
   let id = 0;
+  let sendBatchTimeoutHandle: NodeJS.Timeout | undefined;
+  let queue: Array<{ request: JsonRpcRequest; deferred: PromiseWithResolvers<JsonRpcResponse> }> = [];
+
+  const sendBatch = async () => {
+    if (sendBatchTimeoutHandle !== undefined) {
+      clearTimeout(sendBatchTimeoutHandle);
+      sendBatchTimeoutHandle = undefined;
+    }
+
+    const rpcCalls = queue;
+    queue = [];
+
+    if (rpcCalls.length === 0) {
+      return;
+    }
+
+    log.debug(`Executing JSON-RPC batch of size: ${rpcCalls.length}`, {
+      methods: rpcCalls.map(({ request }) => request.method),
+    });
+    try {
+      const { response, headers } = await fetch(
+        host,
+        rpcCalls.map(({ request }) => request),
+      );
+
+      if (config.onResponse) {
+        await config.onResponse({ response, headers });
+      }
+
+      if (!Array.isArray(response) || response.length !== rpcCalls.length) {
+        log.warn(
+          `Invalid response received from JSON-RPC server. Expected array of responses of length ${rpcCalls.length}`,
+          { response },
+        );
+        for (let i = 0; i < rpcCalls.length; i++) {
+          const { request, deferred } = rpcCalls[i];
+          deferred.resolve({
+            id: request.id,
+            jsonrpc: '2.0',
+            error: {
+              code: -32000,
+              data: response,
+              message: response.message ?? 'Failed request',
+            },
+          });
+        }
+      } else {
+        for (let i = 0; i < response.length; i++) {
+          const resp: JsonRpcResponse = response[i];
+          const { request, deferred } = rpcCalls[i];
+
+          if (resp.id !== request.id) {
+            log.warn(`Invalid response received at index ${i} from JSON-RPC server: id mismatch`, {
+              requestMethod: request.method,
+              requestId: request.id,
+              responseId: resp.id,
+            });
+            deferred.resolve({
+              id: request.id,
+              jsonrpc: '2.0',
+              error: {
+                code: -32001,
+                data: resp,
+                message: 'RPC id mismatch',
+              },
+            });
+          } else {
+            deferred.resolve(resp);
+          }
+        }
+      }
+    } catch (err) {
+      log.warn(`Failed to fetch from the remote server`, err);
+      for (let i = 0; i < rpcCalls.length; i++) {
+        const { request, deferred } = rpcCalls[i];
+        deferred.resolve({
+          id: request.id,
+          jsonrpc: '2.0',
+          error: {
+            code: -32000,
+            data: err,
+            message: (err as any).message ?? 'Failed request',
+          },
+        });
+      }
+    }
+  };
+
   const request = async (methodName: string, params: any[]): Promise<any> => {
     if (!schemaHasMethod(schema, methodName)) {
       throw new Error(`Unspecified method ${methodName} in client schema`);
     }
     const method = namespaceMethods ? `${namespaceMethods}_${methodName}` : methodName;
-    const body = { jsonrpc: '2.0', id: id++, method, params };
+    const body: JsonRpcRequest = { jsonrpc: '2.0', id: id++, method, params };
+
+    const deferred = promiseWithResolvers<JsonRpcResponse>();
+    queue.push({ request: body, deferred });
+
+    if (sendBatchTimeoutHandle === undefined) {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      sendBatchTimeoutHandle = setTimeout(sendBatch, batchWindowMS);
+    }
 
     log.debug(format(`request`, method, params));
-    const { response, headers } = await fetch(host, method, body, useApiEndpoints);
+    const response = await deferred.promise;
     log.debug(format(`result`, method, response));
 
-    if (config.onResponse) {
-      await config.onResponse({ response, headers });
-    }
-    if (response.error) {
-      throw response.error;
+    if ('error' in response) {
+      throw new Error(response.error.message, { cause: response.error });
     }
     // TODO(palla/schemas): Find a better way to handle null responses (JSON.stringify(null) is string "null").
     if ([null, undefined, 'null', 'undefined'].includes(response.result)) {
@@ -58,10 +182,44 @@ export function createSafeJsonRpcClient<T extends object>(
     return (schema as ApiSchema)[methodName].returnType().parseAsync(response.result);
   };
 
-  const proxy: any = {};
+  const clientId = nextClientId++;
+  const proxy: any = { [CLIENT_ID]: clientId, [SEND_BATCH]: sendBatch };
   for (const method of Object.keys(schema)) {
-    proxy[method] = (...params: any[]) => request(method, params);
+    // attach the clientId to the promise so that if we want to trigger a batch immediately, we can do that
+    proxy[method] = (...params: any[]) => Object.assign(request(method, params), { [CLIENT_ID]: clientId });
   }
 
+  clients.set(clientId, new WeakRef(proxy));
+
   return proxy as T;
 }
+
+/**
+ * Triggers a batch to be sent immediately
+ */
+export async function batch<T extends readonly unknown[]>(
+  values: T,
+): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }> {
+  const clientIdsSeen = new Set<number>();
+
+  await Promise.allSettled(
+    values.map(val => {
+      if (typeof val === 'object' && val && Object.hasOwn(val, CLIENT_ID)) {
+        const clientId = (val as { [CLIENT_ID]: any })[CLIENT_ID];
+        if (typeof clientId === 'number') {
+          if (clientIdsSeen.has(clientId)) {
+            return;
+          }
+
+          clientIdsSeen.add(clientId);
+          const client = clients.get(clientId)?.deref();
+          if (client) {
+            return client[SEND_BATCH]();
+          }
+        }
+      }
+    }),
+  );
+
+  return Promise.all(values);
+}

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

@@ -10,21 +10,14 @@ const log = createLogger('json-rpc:json_rpc_client:undici');
 export { Agent };
 
 export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
-  return async (
-    host: string,
-    rpcMethod: string,
-    body: any,
-    useApiEndpoints: boolean,
-    extraHeaders: Record<string, string> = {},
-    noRetry = false,
-  ) => {
-    log.trace(`JsonRpcClient.fetch: ${host} ${rpcMethod}`, { host, rpcMethod, body });
+  return async (host: string, body: unknown, extraHeaders: Record<string, string> = {}, noRetry = false) => {
+    log.trace(`JsonRpcClient.fetch: ${host}`, { host, body });
     let resp: Dispatcher.ResponseData;
     try {
       resp = await client.request({
         method: 'POST',
         origin: new URL(host),
-        path: useApiEndpoints ? rpcMethod : '/',
+        path: '/',
         body: jsonStringify(body),
         headers: {
           ...extraHeaders,
@@ -32,7 +25,7 @@ export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
         },
       });
     } catch (err) {
-      const errorMessage = `Error fetching from host ${host} with method ${rpcMethod}: ${String(err)}`;
+      const errorMessage = `Error fetching from host ${host}: ${String(err)}`;
       throw new Error(errorMessage);
     }
 
@@ -40,7 +33,7 @@ export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
     const responseOk = resp.statusCode >= 200 && resp.statusCode <= 299;
     try {
       responseJson = await resp.body.json();
-    } catch (err) {
+    } catch {
       if (!responseOk) {
         throw new Error('HTTP ' + resp.statusCode);
       }
@@ -48,7 +41,7 @@ export function makeUndiciFetch(client = new Agent()): JsonRpcFetch {
     }
 
     if (!responseOk) {
-      const errorMessage = `Error ${resp.statusCode} response from server ${host} on ${rpcMethod}: ${responseJson.error.message}`;
+      const errorMessage = `Error ${resp.statusCode} response from server ${host}: ${responseJson}`;
       if (noRetry || (resp.statusCode >= 400 && resp.statusCode < 500)) {
         throw new NoRetryError(errorMessage);
       } else {

package/src/json-rpc/convert.ts

@@ -26,7 +26,7 @@ export function jsonParseWithSchemaSync<T>(json: string, schema: ZodFor<T>): T {
  * @param obj - The object to be stringified.
  * @returns The resulting string.
  */
-export function jsonStringify(obj: object, prettify?: boolean): string {
+export function jsonStringify(obj: unknown, prettify?: boolean): string {
   return JSON.stringify(
     obj,
     (_key, value) => {
@@ -55,7 +55,7 @@ export function jsonStringify(obj: object, prettify?: boolean): string {
 export function tryJsonStringify(obj: any, prettify?: boolean): string | undefined {
   try {
     return jsonStringify(obj, prettify);
-  } catch (e) {
+  } catch {
     return undefined;
   }
 }

package/src/json-rpc/errors.ts

@@ -0,0 +1,6 @@
+export class BadRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BadRequestError';
+  }
+}

package/src/json-rpc/fixtures/class_a.ts

@@ -2,7 +2,10 @@
  * Test class for testing string converter.
  */
 export class ToStringClass {
-  constructor(/** A value */ public readonly x: string, /** Another value */ public readonly y: string) {}
+  constructor(
+    /** A value */ public readonly x: string,
+    /** Another value */ public readonly y: string,
+  ) {}
 
   toString(): string {
     return [this.x, this.y].join('-');

package/src/json-rpc/fixtures/class_b.ts

@@ -2,7 +2,10 @@
  * Test class for testing string converter.
  */
 export class ToStringClass {
-  constructor(/** A value */ public readonly x: string, /** Another value */ public readonly y: string) {}
+  constructor(
+    /** A value */ public readonly x: string,
+    /** Another value */ public readonly y: string,
+  ) {}
 
   toString(): string {
     return [this.x, this.y].join('-');

package/src/json-rpc/index.ts

@@ -1 +1,2 @@
 export { jsonStringify, jsonParseWithSchema, jsonParseWithSchemaSync, tryJsonStringify } from './convert.js';
+export { BadRequestError } from './errors.js';

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

@@ -63,20 +63,13 @@ export class SafeJsonRpcServer {
         await next();
       } catch (err: any) {
         const method = (ctx.request.body as any)?.method ?? 'unknown';
-        this.log.warn(`Error in JSON RPC server call ${method}: ${inspect(err)}`);
-        if (err instanceof SyntaxError) {
+        this.log.warn(`Uncaught error in JSON RPC server call ${method}: ${inspect(err)}`);
+        if (err && 'name' in err && err.name === 'BadRequestError') {
           ctx.status = 400;
-          ctx.body = { jsonrpc: '2.0', id: null, error: { code: -32700, message: `Parse error: ${err.message}` } };
-        } else if (err instanceof ZodError) {
-          const message = err.issues.map(e => `${e.message} (${e.path.join('.')})`).join('. ') || 'Validation error';
+          ctx.body = { jsonrpc: '2.0', id: null, error: { code: -32000, message: `Bad request: ${err.message}` } };
+        } else if (err && err instanceof SyntaxError) {
           ctx.status = 400;
-          ctx.body = { jsonrpc: '2.0', id: null, error: { code: -32701, message } };
-        } else if (this.http200OnError) {
-          ctx.body = {
-            jsonrpc: '2.0',
-            id: null,
-            error: { code: err.code || -32600, data: err.data, message: err.message },
-          };
+          ctx.body = { jsonrpc: '2.0', id: null, error: { code: -32700, message: `Parse error: ${err.message}` } };
         } else {
           ctx.status = 500;
           ctx.body = { jsonrpc: '2.0', id: null, error: { code: -32600, message: err.message ?? 'Internal error' } };
@@ -124,23 +117,77 @@ export class SafeJsonRpcServer {
     const router = new Router({ prefix });
     // "JSON RPC mode" where a single endpoint is used and the method is given in the request body
     router.post('/', async (ctx: Koa.Context) => {
-      const { params = [], jsonrpc, id, method } = ctx.request.body as any;
-      // Fail if not a registered function in the proxy
-      if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
-        ctx.status = 400;
-        const code = -32601;
-        const message = `Method not found: ${method}`;
-        ctx.body = { jsonrpc, id, error: { code, message } };
+      if (Array.isArray(ctx.request.body)) {
+        const resp = await this.processBatch(ctx.request.body);
+        if (Array.isArray(resp)) {
+          ctx.status = 200;
+          ctx.body = resp;
+        } else {
+          ctx.status = this.http200OnError ? 200 : 400;
+          ctx.body = resp;
+        }
       } else {
-        ctx.status = 200;
-        const result = await this.proxy.call(method, params);
-        ctx.body = { jsonrpc, id, result };
+        const resp = await this.processRequest(ctx.request.body);
+        if ('error' in resp) {
+          ctx.status = this.http200OnError ? 200 : 400;
+        }
+
+        ctx.body = resp;
       }
     });
 
     return router;
   }
 
+  private async processBatch(requests: any[]) {
+    if (requests.length === 0) {
+      return { jsonrpc: '2.0', error: { code: -32600, message: 'Invalid Request' }, id: null };
+    }
+    const results = await Promise.allSettled(requests.map(req => this.processRequest(req)));
+    return results.map(res => {
+      if (res.status === 'fulfilled') {
+        return res.value;
+      }
+
+      this.log.warn(`Uncaught error executing request in batch: ${res.reason}.`);
+      return { jsonrpc: '2.0', error: { code: -32600, message: 'Invalid Request' }, id: null };
+    });
+  }
+
+  private async processRequest(request: any) {
+    if (!request || typeof request !== 'object') {
+      return { jsonrpc: '2.0', error: { code: -32600, message: 'Invalid Request' }, id: null };
+    }
+
+    const { params = [], jsonrpc, id, method } = request;
+    // Fail if not a registered function in the proxy
+    if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
+      return { jsonrpc, id, error: { code: -32601, message: `Method not found: ${method}` } };
+    } else {
+      try {
+        const result = await this.proxy.call(method, params);
+        return { jsonrpc, id, result };
+      } catch (err: any) {
+        if (err && err instanceof ZodError) {
+          const message = err.issues.map(e => `${e.message} (${e.path.join('.')})`).join('. ') || 'Validation error';
+          return { jsonrpc: '2.0', id, error: { code: -32701, message } };
+        } else if (err) {
+          return {
+            jsonrpc,
+            id,
+            error: { code: -32702, data: err.data, message: err.message },
+          };
+        } else {
+          return {
+            jsonrpc,
+            id,
+            error: { code: -32702, message: 'Error executing request' },
+          };
+        }
+      }
+    }
+  }
+
   /**
    * Start this server with koa.
    * @param port - Port number.
@@ -201,7 +248,10 @@ export class SafeJsonProxy<T extends object = any> implements Proxy {
   private log = createLogger('json-rpc:proxy');
   private schema: ApiSchema;
 
-  constructor(private handler: T, schema: ApiSchemaFor<T>) {
+  constructor(
+    private handler: T,
+    schema: ApiSchemaFor<T>,
+  ) {
     this.schema = schema;
   }
 
@@ -265,7 +315,10 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Lo
   return async () => {
     try {
       const results = await Promise.all(
-        Object.entries(namedHandlers).map(([name, [, , healthCheck]]) => [name, healthCheck ? healthCheck() : true]),
+        Object.entries(namedHandlers).map(async ([name, [, , healthCheck]]) => [
+          name,
+          healthCheck ? await healthCheck() : true,
+        ]),
       );
       const failed = results.filter(([_, result]) => !result);
       if (failed.length > 0) {
@@ -326,7 +379,7 @@ export function createStatusRouter(getCurrentStatus: StatusCheckFn, apiPrefix =
     let ok: boolean;
     try {
       ok = (await getCurrentStatus()) === true;
-    } catch (err) {
+    } catch {
       ok = false;
     }
 

package/src/log/console.ts

@@ -7,7 +7,10 @@ import type { LogFn } from './log_fn.js';
  * which can be useful for controlling the format of the output or redirecting logs to a different destination.
  */
 class ConsoleLogger {
-  constructor(private prefix: string, private logger: (...args: any[]) => void = console.log) {}
+  constructor(
+    private prefix: string,
+    private logger: (...args: any[]) => void = console.log,
+  ) {}
 
   /**
    * Log messages with the specified prefix using the provided logger.

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

@@ -39,7 +39,7 @@ export const GoogleCloudLoggerConfig = {
       // 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) {
+      switch (label as pino.Level | keyof CustomLevels) {
         case 'trace':
         case 'debug':
           severity = 'DEBUG';
@@ -68,4 +68,4 @@ export const GoogleCloudLoggerConfig = {
 } satisfies pino.LoggerOptions;
 
 // Define custom logging levels for pino. Duplicate from pino-logger.ts.
-const customLevels = { verbose: 25 };
+type CustomLevels = { verbose: 25 };

package/src/log/pino-logger.ts

@@ -248,7 +248,7 @@ export function registerLoggingStream(stream: Writable): void {
 }
 
 /** Log function that accepts an exception object */
-type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
+type ErrorLogFn = (msg: string, err?: unknown, data?: LogData) => void;
 
 /**
  * Logger that supports multiple severity levels.
@@ -265,6 +265,6 @@ export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ er
  * @param err - Error to log
  * @returns A string with both the log message and the error message.
  */
-function formatErr(msg: string, err?: Error | unknown): string {
+function formatErr(msg: string, err?: unknown): string {
   return err ? `${msg}: ${inspect(err)}` : msg;
 }

package/src/message/index.ts

@@ -31,7 +31,11 @@ interface TypedMessageLike {
 }
 
 export class TypedMessage<T, B> {
-  public constructor(public readonly msgType: T, public readonly header: MessageHeader, public readonly value: B) {}
+  public constructor(
+    public readonly msgType: T,
+    public readonly header: MessageHeader,
+    public readonly value: B,
+  ) {}
 
   static fromMessagePack<T, B>(data: TypedMessageLike): TypedMessage<T, B> {
     return new TypedMessage<T, B>(data['msgType'] as T, MessageHeader.fromMessagePack(data['header']), data['value']);

package/src/mutex/mutex_database.ts

@@ -3,10 +3,9 @@
  * Provides functionality for acquiring, extending, and releasing locks on resources to ensure exclusive access and prevent conflicts in concurrent applications.
  */
 export interface MutexDatabase {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   acquireLock(name: string, timeout: number): Promise<boolean>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   extendLock(name: string, timeout: number): Promise<void>;
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   releaseLock(name: string): Promise<void>;
 }

package/src/queue/bounded_serial_queue.ts

@@ -10,7 +10,10 @@ export class BoundedSerialQueue {
   private readonly queue = new SerialQueue();
   private semaphore: Semaphore;
 
-  constructor(maxQueueSize: number, private log = createLogger('foundation:bounded_serial_queue')) {
+  constructor(
+    maxQueueSize: number,
+    private log = createLogger('foundation:bounded_serial_queue'),
+  ) {
     this.semaphore = new Semaphore(maxQueueSize);
   }
 

package/src/schemas/api.ts

@@ -19,10 +19,10 @@ type ZodReturnTypeFor<T> = z.ZodType<T, z.ZodTypeDef, any>;
 type ZodMapParameterTypes<T> = T extends []
   ? []
   : T extends [item: infer Head, ...infer Rest]
-  ? [ZodParameterTypeFor<Head>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
-  : T extends [item?: infer Head, ...infer Rest]
-  ? [ZodNullableOptional<ZodParameterTypeFor<Head>>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
-  : never;
+    ? [ZodParameterTypeFor<Head>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
+    : T extends [item?: infer Head, ...infer Rest]
+      ? [ZodNullableOptional<ZodParameterTypeFor<Head>>, ...{ [K in keyof Rest]: ZodParameterTypeFor<Rest[K]> }]
+      : never;
 
 /** Maps all functions in an interface to their schema representation. */
 export type ApiSchemaFor<T> = {

package/src/schemas/parse.ts

@@ -22,7 +22,7 @@ export function parseWithOptionals<T extends z.AnyZodTuple>(args: any[], schema:
 function isOptional(schema: z.ZodTypeAny) {
   try {
     return schema.isOptional();
-  } catch (err) {
+  } catch {
     // See https://github.com/colinhacks/zod/issues/1911
     return schema._def.typeName === 'ZodOptional';
   }

package/src/serialize/buffer_reader.ts

@@ -19,7 +19,10 @@ import type { Tuple } from './types.js';
  */
 export class BufferReader {
   private index: number;
-  constructor(private buffer: Buffer, offset = 0) {
+  constructor(
+    private buffer: Buffer,
+    offset = 0,
+  ) {
     this.index = offset;
   }
 
@@ -70,6 +73,23 @@ export class BufferReader {
     return result as Tuple<number, N>;
   }
 
+  /**
+   * Reads a 256-bit unsigned integer from the buffer at the current index position.
+   * Updates the index position by 32 bytes after reading the number.
+   *
+   * Assumes the number is stored in big-endian format.
+   *
+   * @returns The read 256 bit value as a bigint.
+   */
+  public readUInt64(): bigint {
+    this.#rangeCheck(8);
+
+    const result = this.buffer.readBigUInt64BE(this.index);
+
+    this.index += 8;
+    return result;
+  }
+
   /**
    * Reads a 256-bit unsigned integer from the buffer at the current index position.
    * Updates the index position by 32 bytes after reading the number.
@@ -82,8 +102,8 @@ export class BufferReader {
     this.#rangeCheck(32);
 
     let result = BigInt(0);
-    for (let i = 0; i < 32; i++) {
-      result = (result << BigInt(8)) | BigInt(this.buffer[this.index + i]);
+    for (let i = 0; i < 4; i++) {
+      result = (result << BigInt(64)) | this.buffer.readBigUInt64BE(this.index + i * 8);
     }
 
     this.index += 32;