@eip-1193/jsonrpc-provider 0.0.0 → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Ronan Sandford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
 # @eip-1193/jsonrpc-provider
 
-This `0.0.0` is a placeholder holding the name `@eip-1193/jsonrpc-provider`. It contains no code, and is not meant to be installed.
+An [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) provider backed by a JSON-RPC node over HTTP, with optional request throttling and `eth_batch` support.
+
+```bash
+npm install @eip-1193/jsonrpc-provider
+```
+
+Formerly published as `eip-1193-jsonrpc-provider`.

package/dist/index.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+var PromiseThrottle = require('promise-throttle');
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class JSONRPCError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.isInvalidError = true;
+  }
+}
+let counter = 0;
+function ethereum_request(endpoint, req) {
+  return __async(this, null, function* () {
+    const { method, params } = req;
+    if (method === "eth_batch") {
+      if (params && params.length === 0) {
+        return [];
+      }
+      const requests = [];
+      for (const param of params) {
+        requests.push({
+          id: ++counter,
+          jsonrpc: "2.0",
+          method: param.method,
+          params: param.params || []
+        });
+      }
+      let response2;
+      try {
+        response2 = yield fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(requests)
+        });
+      } catch (fetchError) {
+        throw new JSONRPCError(`Failed To Batch Fetch at ${endpoint}`, fetchError);
+      }
+      if (response2.status != 200) {
+        throw new JSONRPCError(
+          `Failed To Batch Fetch (Status = ${response2.status}) at ${endpoint}`,
+          new Error(`status: ${response2.status}`)
+        );
+      }
+      let jsonArray;
+      try {
+        jsonArray = yield response2.json();
+      } catch (parsingError) {
+        throw new JSONRPCError("Failed To Batch parse response as json", parsingError);
+      }
+      let hasError = false;
+      for (const response3 of jsonArray) {
+        if (response3.error || !("result" in response3)) {
+          hasError = true;
+        }
+      }
+      if (hasError) {
+        throw jsonArray;
+      }
+      return jsonArray.map((v) => v.result);
+    }
+    let response;
+    try {
+      response = yield fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: ++counter,
+          jsonrpc: "2.0",
+          method,
+          params: params || []
+        })
+      });
+    } catch (fetchError) {
+      throw new JSONRPCError(`Failed To Fetch at ${endpoint} (method: ${method})`, fetchError);
+    }
+    if (response.status != 200) {
+      throw new JSONRPCError(
+        `Failed To Fetch (status = ${response.status}) at ${endpoint} (method: ${method})`,
+        new Error(`status: ${response.status}`)
+      );
+    }
+    let json;
+    try {
+      json = yield response.json();
+    } catch (parsingError) {
+      throw new JSONRPCError("Failed To parse response json", parsingError);
+    }
+    if (json.error) {
+      throw json.error;
+    }
+    if (!("result" in json)) {
+      throw { code: 5e3, message: "No Result" };
+    }
+    return json.result;
+  });
+}
+class JSONRPCHTTPProvider {
+  constructor(endpoint, options) {
+    this.endpoint = endpoint;
+    this.supportsETHBatch = true;
+    if (options == null ? void 0 : options.requestsPerSecond) {
+      this.promiseThrottle = new PromiseThrottle({
+        requestsPerSecond: options.requestsPerSecond,
+        promiseImplementation: Promise
+      });
+    }
+  }
+  request(args) {
+    if (this.promiseThrottle) {
+      return this.promiseThrottle.add(ethereum_request.bind(null, this.endpoint, args));
+    } else {
+      return ethereum_request(this.endpoint, args);
+    }
+  }
+}
+
+exports.JSONRPCError = JSONRPCError;
+exports.JSONRPCHTTPProvider = JSONRPCHTTPProvider;
+exports.ethereum_request = ethereum_request;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { EIP1193HttpNodeProvider } from 'eip-1193';
+
+declare class JSONRPCError extends Error {
+    cause: Error;
+    readonly isInvalidError = true;
+    constructor(message: string, cause: Error);
+}
+declare function ethereum_request<U extends any, T>(endpoint: string, req: {
+    method: string;
+    params?: U;
+}): Promise<T>;
+declare class JSONRPCHTTPProvider implements EIP1193HttpNodeProvider {
+    protected endpoint: string;
+    supportsETHBatch: boolean;
+    private promiseThrottle;
+    constructor(endpoint: string, options?: {
+        requestsPerSecond?: number;
+    });
+    request(args: {
+        method: string;
+        params?: any;
+    }): Promise<any>;
+}
+
+export { JSONRPCError, JSONRPCHTTPProvider, ethereum_request };

package/dist/index.mjs

@@ -0,0 +1,136 @@
+import PromiseThrottle from 'promise-throttle';
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class JSONRPCError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.isInvalidError = true;
+  }
+}
+let counter = 0;
+function ethereum_request(endpoint, req) {
+  return __async(this, null, function* () {
+    const { method, params } = req;
+    if (method === "eth_batch") {
+      if (params && params.length === 0) {
+        return [];
+      }
+      const requests = [];
+      for (const param of params) {
+        requests.push({
+          id: ++counter,
+          jsonrpc: "2.0",
+          method: param.method,
+          params: param.params || []
+        });
+      }
+      let response2;
+      try {
+        response2 = yield fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(requests)
+        });
+      } catch (fetchError) {
+        throw new JSONRPCError(`Failed To Batch Fetch at ${endpoint}`, fetchError);
+      }
+      if (response2.status != 200) {
+        throw new JSONRPCError(
+          `Failed To Batch Fetch (Status = ${response2.status}) at ${endpoint}`,
+          new Error(`status: ${response2.status}`)
+        );
+      }
+      let jsonArray;
+      try {
+        jsonArray = yield response2.json();
+      } catch (parsingError) {
+        throw new JSONRPCError("Failed To Batch parse response as json", parsingError);
+      }
+      let hasError = false;
+      for (const response3 of jsonArray) {
+        if (response3.error || !("result" in response3)) {
+          hasError = true;
+        }
+      }
+      if (hasError) {
+        throw jsonArray;
+      }
+      return jsonArray.map((v) => v.result);
+    }
+    let response;
+    try {
+      response = yield fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: ++counter,
+          jsonrpc: "2.0",
+          method,
+          params: params || []
+        })
+      });
+    } catch (fetchError) {
+      throw new JSONRPCError(`Failed To Fetch at ${endpoint} (method: ${method})`, fetchError);
+    }
+    if (response.status != 200) {
+      throw new JSONRPCError(
+        `Failed To Fetch (status = ${response.status}) at ${endpoint} (method: ${method})`,
+        new Error(`status: ${response.status}`)
+      );
+    }
+    let json;
+    try {
+      json = yield response.json();
+    } catch (parsingError) {
+      throw new JSONRPCError("Failed To parse response json", parsingError);
+    }
+    if (json.error) {
+      throw json.error;
+    }
+    if (!("result" in json)) {
+      throw { code: 5e3, message: "No Result" };
+    }
+    return json.result;
+  });
+}
+class JSONRPCHTTPProvider {
+  constructor(endpoint, options) {
+    this.endpoint = endpoint;
+    this.supportsETHBatch = true;
+    if (options == null ? void 0 : options.requestsPerSecond) {
+      this.promiseThrottle = new PromiseThrottle({
+        requestsPerSecond: options.requestsPerSecond,
+        promiseImplementation: Promise
+      });
+    }
+  }
+  request(args) {
+    if (this.promiseThrottle) {
+      return this.promiseThrottle.add(ethereum_request.bind(null, this.endpoint, args));
+    } else {
+      return ethereum_request(this.endpoint, args);
+    }
+  }
+}
+
+export { JSONRPCError, JSONRPCHTTPProvider, ethereum_request };

package/package.json

@@ -1,10 +1,66 @@
 {
-	"name": "@eip-1193/jsonrpc-provider",
-	"version": "0.0.0",
-	"description": "Name reservation for @eip-1193/jsonrpc-provider. A real release follows; this 0.0.0 holds the name and contains no code.",
-	"license": "AGPL-3.0-only",
-	"private": false,
-	"publishConfig": {
-		"access": "public"
-	}
-}
+  "name": "@eip-1193/jsonrpc-provider",
+  "version": "0.6.0",
+  "keywords": [
+    "eip-1193",
+    "ethereum",
+    "provider",
+    "json-rpc",
+    "http",
+    "batch",
+    "throttle"
+  ],
+  "author": "wighawag <wighawag@gmail.com>",
+  "homepage": "https://github.com/wighawag/eip-1193-jsonrpc-provider#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wighawag/eip-1193-jsonrpc-provider.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wighawag/eip-1193-jsonrpc-provider/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "pkgroll": "^2.0.2",
+    "prettier": "^3.2.5",
+    "set-defaults": "^0.0.5",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "eip-1193": "^0.7.0",
+    "named-logs": "^0.3.2",
+    "promise-throttle": "^1.1.2"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "dev": "pkgroll --watch",
+    "format:check": "prettier --check .",
+    "test": "pnpm build && node --test test/*.test.mjs",
+    "format": "prettier --write .",
+    "release:ci": "pnpm format:check && pnpm test && pnpm changeset publish"
+  }
+}

package/src/JSONRPCHTTPProvider.ts

@@ -0,0 +1,140 @@
+import type {EIP1193HttpNodeProvider} from 'eip-1193';
+import PromiseThrottle from 'promise-throttle';
+
+export class JSONRPCError extends Error {
+	public readonly isInvalidError = true;
+	constructor(
+		message: string,
+		public cause: Error,
+	) {
+		super(message);
+	}
+}
+
+let counter = 0;
+export async function ethereum_request<U extends any, T>(
+	endpoint: string,
+	req: {method: string; params?: U},
+): Promise<T> {
+	const {method, params} = req;
+	// NOTE: special case to allow batch request via EIP-1193
+	if (method === 'eth_batch') {
+		if (params && (params as any[]).length === 0) {
+			return [] as unknown as T;
+		}
+		const requests = [];
+		for (const param of params as {method: string; params?: any[]}[]) {
+			requests.push({
+				id: ++counter,
+				jsonrpc: '2.0',
+				method: param.method,
+				params: param.params || [],
+			});
+		}
+
+		let response: Response;
+		try {
+			response = await fetch(endpoint, {
+				method: 'POST',
+				headers: {'Content-Type': 'application/json'},
+				body: JSON.stringify(requests),
+			});
+		} catch (fetchError) {
+			throw new JSONRPCError(`Failed To Batch Fetch at ${endpoint}`, fetchError);
+		}
+
+		if (response.status != 200) {
+			throw new JSONRPCError(
+				`Failed To Batch Fetch (Status = ${response.status}) at ${endpoint}`,
+				new Error(`status: ${response.status}`),
+			);
+		}
+
+		let jsonArray: {result?: T; error?: any}[];
+		try {
+			jsonArray = await response.json();
+		} catch (parsingError) {
+			throw new JSONRPCError('Failed To Batch parse response as json', parsingError);
+		}
+
+		let hasError = false;
+		for (const response of jsonArray) {
+			// `null`, `false` and `0` are valid results (a pending receipt, `eth_syncing`,
+			//  `hardhat_impersonateAccount`): only an error, or a missing `result` member, is a failure.
+			if (response.error || !('result' in response)) {
+				hasError = true;
+			}
+		}
+
+		if (hasError) {
+			throw jsonArray;
+		}
+
+		return jsonArray.map((v) => v.result) as unknown as T;
+	}
+	let response: Response;
+	try {
+		response = await fetch(endpoint, {
+			method: 'POST',
+			headers: {'Content-Type': 'application/json'},
+			body: JSON.stringify({
+				id: ++counter,
+				jsonrpc: '2.0',
+				method,
+				params: params || [],
+			}),
+		});
+	} catch (fetchError) {
+		throw new JSONRPCError(`Failed To Fetch at ${endpoint} (method: ${method})`, fetchError);
+	}
+
+	if (response.status != 200) {
+		throw new JSONRPCError(
+			`Failed To Fetch (status = ${response.status}) at ${endpoint} (method: ${method})`,
+			new Error(`status: ${response.status}`),
+		);
+	}
+	let json: {result?: T; error?: any};
+	try {
+		json = await response.json();
+	} catch (parsingError) {
+		throw new JSONRPCError('Failed To parse response json', parsingError);
+	}
+
+	if (json.error) {
+		throw json.error;
+	}
+	// A JSON-RPC response carries EITHER `error` OR `result`, and `result` may legitimately be
+	//  `null` or `false` (a pending `eth_getTransactionReceipt`, `eth_syncing`, and
+	//  `hardhat_impersonateAccount`, which anvil and hardhat answer with `null`). Only a response
+	//  with neither member is malformed.
+	if (!('result' in json)) {
+		throw {code: 5000, message: 'No Result'};
+	}
+	return json.result as T;
+}
+
+export class JSONRPCHTTPProvider implements EIP1193HttpNodeProvider {
+	supportsETHBatch = true;
+	private promiseThrottle: PromiseThrottle | undefined;
+	constructor(
+		protected endpoint: string,
+		options?: {requestsPerSecond?: number},
+	) {
+		if (options?.requestsPerSecond) {
+			this.promiseThrottle = new PromiseThrottle({
+				requestsPerSecond: options.requestsPerSecond,
+				promiseImplementation: Promise,
+			});
+		}
+	}
+
+	request(args: {method: string; params?: any}): Promise<any>;
+	request<T, U extends any = any>(args: {method: string; params: U}): Promise<T> {
+		if (this.promiseThrottle) {
+			return this.promiseThrottle.add(ethereum_request.bind(null, this.endpoint, args));
+		} else {
+			return ethereum_request<U, T>(this.endpoint, args);
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './JSONRPCHTTPProvider';