feat: rpc batch requests

src/batch/default.ts

@@ -0,0 +1,75 @@
+import { BatchClientOptions } from './interface';
+import { DelayedAction } from './delayedAction';
+import { stringify } from '../utils/json';
+import { RPC } from '../types';
+import { JRPC } from '../types/api';
+
+export class BatchClient extends DelayedAction {
+  public nodeUrl: string;
+
+  public headers: object;
+
+  public interval: number;
+
+  public requestId: number = 0;
+
+  private pendingRequests: Record<string | number, JRPC.RequestBody> = {};
+
+  private batchPromise?: Promise<any>;
+
+  constructor(options: BatchClientOptions) {
+    super(options.interval);
+
+    this.nodeUrl = options.nodeUrl;
+    this.headers = options.headers;
+    this.interval = options.interval;
+  }
+
+  private addPendingRequest<T extends keyof RPC.Methods>(
+    method: T,
+    params?: RPC.Methods[T]['params'],
+    id?: string | number
+  ) {
+    const request: JRPC.RequestBody = {
+      id: id ?? `batched_${(this.requestId += 1)}`,
+      jsonrpc: '2.0',
+      method,
+      params: params ?? undefined,
+    };
+
+    this.pendingRequests[request.id] = request;
+
+    return request.id;
+  }
+
+  private async sendBatch(requests: JRPC.RequestBody[]) {
+    const raw = await fetch(this.nodeUrl, {
+      method: 'POST',
+      body: stringify(requests),
+      headers: this.headers as Record<string, string>,
+    });
+
+    return raw.json();
+  }
+
+  public async fetch<T extends keyof RPC.Methods>(
+    method: T,
+    params?: RPC.Methods[T]['params'],
+    id?: string | number
+  ) {
+    const requestId = this.addPendingRequest(method, params, id);
+
+    await this.wait();
+
+    const requests = this.pendingRequests;
+    this.pendingRequests = {};
+
+    if (!this.batchPromise) {
+      this.batchPromise = this.sendBatch(Object.values(requests));
+    }
+    const results = await this.batchPromise;
+    this.batchPromise = undefined;
+
+    return results.find((result: any) => result.id === requestId);
+  }
+}

src/batch/delayedAction.ts

@@ -0,0 +1,46 @@
+export class DelayedAction {
+  private delay: number;
+
+  private timer: NodeJS.Timeout | null;
+
+  private promise?: Promise<void>;
+
+  private promiseResolve?: () => void;
+
+  constructor(delay: number = 5000) {
+    this.delay = delay;
+    this.timer = null;
+  }
+
+  /**
+   * Waits for the delay to pass, then resolves the promise.
+   * All calls to this method will return the same promise until the delay has passed
+   *
+   * @returns {Promise<void>}
+   */
+  public async wait(): Promise<void> {
+    // If the promise is not set, create a new one and store the resolve function
+    if (!this.promise || !this.promiseResolve) {
+      this.promise = new Promise((resolve) => {
+        this.promiseResolve = resolve;
+      });
+    }
+
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    this.timer = setTimeout(() => {
+      if (this.promiseResolve) {
+        this.promiseResolve();
+
+        // Reset the promise and resolve function so that a new promise is created next time
+        this.promise = undefined;
+        this.promiseResolve = undefined;
+      }
+    }, this.delay);
+
+    return this.promise;
+  }
+}

src/batch/index.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './default';

src/batch/interface.ts

@@ -0,0 +1,32 @@
+import { RPC } from '../types';
+import { JRPC } from '../types/api';
+
+export type BatchClientOptions = {
+  nodeUrl: string;
+  headers: object;
+  interval: number;
+};
+
+export abstract class BatchClientInterface {
+  /**
+   * Fetch batched JSON-RPC requests
+   *
+   * @param body - JSON-RPC request body
+   * @returns JSON-RPC response
+   */
+  public abstract fetch<T extends keyof RPC.Methods>(
+    method: T,
+    params?: RPC.Methods[T]['params'],
+    id?: string | number
+  ): Promise<
+    JRPC.ResponseBody &
+      (
+        | {
+            result?: RPC.Methods[T]['result'];
+          }
+        | {
+            error?: RPC.Methods[T] extends { error: infer E } ? E : never;
+          }
+      )
+  >;
+}

src/channel/rpc_0_6.ts

@@ -1,3 +1,4 @@
+import { BatchClient } from '../batch';
 import { NetworkName, StarknetChainId } from '../constants';
 import { LibraryError } from '../provider/errors';
 import {
@@ -52,8 +53,10 @@ export class RpcChannel {
 
   readonly waitMode: Boolean; // behave like web2 rpc and return when tx is processed
 
+  private batchClient?: BatchClient;
+
   constructor(optionsOrProvider?: RpcProviderOptions) {
-    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode } =
+    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode, batch } =
       optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl as NetworkName)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl as NetworkName, optionsOrProvider?.default);
@@ -69,6 +72,14 @@ export class RpcChannel {
     this.specVersion = specVersion;
     this.waitMode = waitMode || false;
     this.requestId = 0;
+
+    if (typeof batch === 'number') {
+      this.batchClient = new BatchClient({
+        nodeUrl: this.nodeUrl,
+        headers: this.headers,
+        interval: batch,
+      });
+    }
   }
 
   public setChainId(chainId: StarknetChainId) {
@@ -110,6 +121,16 @@ export class RpcChannel {
     params?: RPC.Methods[T]['params']
   ): Promise<RPC.Methods[T]['result']> {
     try {
+      if (this.batchClient) {
+        const { error, result } = await this.batchClient.fetch(
+          method,
+          params,
+          (this.requestId += 1)
+        );
+        this.errorHandler(method, params, error);
+        return result as RPC.Methods[T]['result'];
+      }
+
       const rawResult = await this.fetch(method, params, (this.requestId += 1));
       const { error, result } = await rawResult.json();
       this.errorHandler(method, params, error);

src/channel/rpc_0_7.ts

@@ -1,3 +1,4 @@
+import { BatchClient } from '../batch';
 import { NetworkName, StarknetChainId } from '../constants';
 import { LibraryError } from '../provider/errors';
 import {
@@ -54,6 +55,8 @@ export class RpcChannel {
 
   readonly waitMode: Boolean; // behave like web2 rpc and return when tx is processed
 
+  private batchClient?: BatchClient;
+
   constructor(optionsOrProvider?: RpcProviderOptions) {
     const {
       nodeUrl,
@@ -64,6 +67,7 @@ export class RpcChannel {
       specVersion,
       waitMode,
       transactionRetryIntervalFallback,
+      batch,
     } = optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl as NetworkName)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl as NetworkName, optionsOrProvider?.default);
@@ -80,6 +84,14 @@ export class RpcChannel {
     this.waitMode = waitMode || false;
     this.requestId = 0;
     this.transactionRetryIntervalFallback = transactionRetryIntervalFallback;
+
+    if (typeof batch === 'number') {
+      this.batchClient = new BatchClient({
+        nodeUrl: this.nodeUrl,
+        headers: this.headers,
+        interval: batch,
+      });
+    }
   }
 
   private get transactionRetryIntervalDefault() {
@@ -125,6 +137,16 @@ export class RpcChannel {
     params?: RPC.Methods[T]['params']
   ): Promise<RPC.Methods[T]['result']> {
     try {
+      if (this.batchClient) {
+        const { error, result } = await this.batchClient.fetch(
+          method,
+          params,
+          (this.requestId += 1)
+        );
+        this.errorHandler(method, params, error);
+        return result as RPC.Methods[T]['result'];
+      }
+
       const rawResult = await this.fetch(method, params, (this.requestId += 1));
       const { error, result } = await rawResult.json();
       this.errorHandler(method, params, error);

src/types/provider/configuration.ts

@@ -18,4 +18,5 @@ export type RpcProviderOptions = {
     l1BoundMaxPricePerUnit: number;
     maxFee: number;
   };
+  batch?: false | number;
 };