@appliedblockchain/silentdatarollup-custom-rpc 1.0.0

package/README.md

@@ -0,0 +1,70 @@
+# Silent Data [Rollup] Providers - Custom RPC Package
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Prerequisites](#prerequisites)
+- [Integration](#integration)
+  - [Custom RPC Integration](#custom-rpc-integration)
+    - [Installing Custom RPC Dependencies](#installing-custom-rpc-dependencies)
+    - [Custom RPC Integration Example](#custom-rpc-integration-example)
+- [Troubleshooting](#troubleshooting)
+- [License](#license)
+- [Additional Resources](#additional-resources)
+
+## Introduction
+
+Custom RPC provider for Silent Data [Rollup], providing a local development environment with Silent Data [Rollup] integration.
+
+## Prerequisites
+
+- Node.js (version 18 or higher)
+- npm
+- Basic knowledge of Ethereum and smart contracts
+- Hardhat (for local development)
+
+## Integration
+
+### Custom RPC Integration
+
+#### Installing Custom RPC Dependencies
+
+```bash
+npm install @appliedblockchain/silentdatarollup-custom-rpc
+```
+
+#### Custom RPC Integration Example
+
+The Custom RPC package provides a local development environment that integrates Silent Data [Rollup] with a local Hardhat node. To start the development environment:
+
+```bash
+npm run dev
+```
+
+This command will start both a Hardhat node and the Custom RPC server concurrently. The Custom RPC server will proxy requests to the Hardhat node while adding Silent Data [Rollup] functionality.
+
+You can configure the Custom RPC server by creating a `.env` file in your project root:
+
+```env
+PORT=3000
+HARDHAT_RPC_URL=http://localhost:8545
+```
+
+## Troubleshooting
+
+If you encounter any issues, please check the following:
+
+1. Ensure Hardhat is properly installed and configured
+2. Verify that the port specified in your `.env` file is available
+3. Check that the Hardhat node is running and accessible
+4. Ensure all required environment variables are set
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+
+## Additional Resources
+
+- [Silent Data [Rollup] Documentation](https://docs.silentdata.com)
+- [Hardhat Documentation](https://hardhat.org/docs)
+- [Ethers.js Documentation](https://docs.ethers.org/v6/)

package/dist/index.js

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_config = require("dotenv/config");
+var import_express = __toESM(require("express"));
+var import_body_parser = __toESM(require("body-parser"));
+var import_http_proxy_middleware = require("http-proxy-middleware");
+var import_ethers2 = require("ethers");
+
+// src/middleware.ts
+var import_silentdatarollup_core2 = require("@appliedblockchain/silentdatarollup-core");
+
+// src/signatures.ts
+var import_ethers = require("ethers");
+var import_silentdatarollup_core = require("@appliedblockchain/silentdatarollup-core");
+var TIMESTAMP_MIN_OFFSET = -12;
+var TIMESTAMP_MAX_OFFSET = 4;
+function validateRFC3339Timestamp(timestamp) {
+  const rfc3339Pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+  if (!rfc3339Pattern.test(timestamp)) {
+    return false;
+  }
+  const timestampDate = new Date(timestamp);
+  if (Number.isNaN(timestampDate.getTime())) {
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const minAllowedTime = new Date(
+    now.getTime() + TIMESTAMP_MIN_OFFSET * 60 * 1e3
+  );
+  const maxAllowedTime = new Date(
+    now.getTime() + TIMESTAMP_MAX_OFFSET * 60 * 1e3
+  );
+  return timestampDate >= minAllowedTime && timestampDate <= maxAllowedTime;
+}
+function recoverSerialSigner(message, signature) {
+  try {
+    const messageHash = import_ethers.ethers.hashMessage(message);
+    const recoveredAddress = import_ethers.ethers.recoverAddress(messageHash, signature);
+    return recoveredAddress;
+  } catch {
+    return null;
+  }
+}
+function recoverTypedSigner(data, signature) {
+  try {
+    const domain = import_silentdatarollup_core.eip721Domain;
+    const types = {
+      Request: [
+        { name: "method", type: "string" },
+        { name: "params", type: "string" },
+        { name: "timestamp", type: "string" }
+      ]
+    };
+    const recoveredAddress = import_ethers.ethers.verifyTypedData(
+      domain,
+      types,
+      data,
+      signature
+    );
+    return recoveredAddress;
+  } catch {
+    return null;
+  }
+}
+function recoverSignerWithDelegate(delegateTicket, delegateSignature, message, isEIP712) {
+  try {
+    const ticket = JSON.parse(delegateTicket);
+    if (!ticket.expires || !ticket.ephemeralAddress) {
+      return null;
+    }
+    const expiryDate = new Date(ticket.expires);
+    if (Number.isNaN(expiryDate.getTime()) || expiryDate <= /* @__PURE__ */ new Date()) {
+      return null;
+    }
+    let delegateAddress;
+    if (isEIP712) {
+      const data = {
+        method: JSON.parse(message).method,
+        params: JSON.stringify(JSON.parse(message).params),
+        timestamp: ticket.timestamp
+      };
+      delegateAddress = recoverTypedSigner(data, delegateSignature);
+    } else {
+      delegateAddress = recoverSerialSigner(message, delegateSignature);
+    }
+    if (!delegateAddress || delegateAddress.toLowerCase() !== ticket.ephemeralAddress.toLowerCase()) {
+      return null;
+    }
+    const ticketData = {
+      expires: ticket.expires,
+      ephemeralAddress: ticket.ephemeralAddress
+    };
+    const delegatorAddress = import_ethers.ethers.verifyTypedData(
+      import_silentdatarollup_core.eip721Domain,
+      import_silentdatarollup_core.delegateEIP721Types,
+      ticketData,
+      ticket.signature
+    );
+    return {
+      delegate: delegateAddress,
+      delegator: delegatorAddress
+    };
+  } catch {
+    return null;
+  }
+}
+function recoverSigner(headers, body) {
+  const timestamp = headers[import_silentdatarollup_core.HEADER_TIMESTAMP];
+  if (!timestamp) {
+    return null;
+  }
+  if (!validateRFC3339Timestamp(timestamp)) {
+    return null;
+  }
+  const delegateTicket = headers[import_silentdatarollup_core.HEADER_DELEGATE];
+  const delegateSignature = headers[import_silentdatarollup_core.HEADER_DELEGATE_SIGNATURE];
+  const eip712DelegateSignature = headers[import_silentdatarollup_core.HEADER_EIP712_DELEGATE_SIGNATURE];
+  const signature = headers[import_silentdatarollup_core.HEADER_SIGNATURE];
+  const eip712Signature = headers[import_silentdatarollup_core.HEADER_EIP712_SIGNATURE];
+  if (signature && eip712Signature || delegateSignature && eip712DelegateSignature) {
+    return null;
+  }
+  if (delegateTicket && (delegateSignature || eip712DelegateSignature)) {
+    const result = recoverSignerWithDelegate(
+      delegateTicket,
+      delegateSignature || eip712DelegateSignature || "",
+      body,
+      !!eip712DelegateSignature
+    );
+    return result ? result.delegator : null;
+  }
+  if (signature) {
+    const message = `${body}${timestamp}`;
+    return recoverSerialSigner(message, signature);
+  }
+  if (eip712Signature) {
+    try {
+      const parsedBody = JSON.parse(body);
+      const data = {
+        method: parsedBody.method,
+        params: JSON.stringify(parsedBody.params),
+        timestamp
+      };
+      return recoverTypedSigner(data, eip712Signature);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function generateRandomKeyPair() {
+  const wallet = import_ethers.ethers.Wallet.createRandom();
+  return {
+    privateKey: wallet.privateKey,
+    address: wallet.address
+  };
+}
+function validateAddress(signer, address) {
+  if (!signer || !address) {
+    return new Error("Missing signer or address");
+  }
+  if (signer.toLowerCase() !== address.toLowerCase()) {
+    return new Error(`Signer ${signer} does not match address ${address}`);
+  }
+  return null;
+}
+function validateMethodAccess(method, params, signer, headers) {
+  switch (method) {
+    case "eth_getTransactionCount":
+    case "eth_getProof":
+      if (!signer) {
+        return true;
+      }
+      if (!params || !params[0]) {
+        return false;
+      }
+      return params[0].toLowerCase() === signer.toLowerCase();
+    case "eth_call":
+      return sanitiseEthCallFrom(params, signer ?? "", headers);
+    default:
+      return false;
+  }
+}
+function sanitiseEthCallFrom(params, signer, headers) {
+  if (!params || params.length === 0) {
+    return false;
+  }
+  const validationError = validateSignerForEthCall(params, signer, headers);
+  if (validationError) {
+    try {
+      let param0;
+      if (typeof params[0] === "object" && params[0] !== null) {
+        param0 = params[0];
+      } else {
+        return false;
+      }
+      const { address } = generateRandomKeyPair();
+      param0.from = address;
+      params[0] = param0;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function validateSignerForEthCall(params, signer, headers) {
+  if (params.length === 0) {
+    const err = new Error("empty params for eth_call");
+    return err;
+  }
+  let param0;
+  if (typeof params[0] === "object" && params[0] !== null) {
+    param0 = params[0];
+  } else {
+    const err = new Error("eth_call param[0] is not a json object");
+    return err;
+  }
+  const hasSignature = headers && (headers[import_silentdatarollup_core.HEADER_SIGNATURE] || headers[import_silentdatarollup_core.HEADER_EIP712_SIGNATURE]);
+  if (!hasSignature) {
+    const err = new Error("no signature provided");
+    return err;
+  }
+  if (param0.from === void 0 || param0.from === null) {
+    param0.from = signer;
+    return null;
+  } else if (typeof param0.from === "string") {
+    const validationError = validateAddress(signer, param0.from);
+    if (validationError) {
+      return validationError;
+    }
+    return null;
+  } else {
+    const err = new Error(
+      "'from' field in eth_call must be a valid address or null"
+    );
+    return err;
+  }
+}
+
+// src/transactions.ts
+function sanitizeTransaction(transaction) {
+  if (!transaction) {
+    return null;
+  }
+  return {
+    blockHash: transaction.blockHash ?? null,
+    blockNumber: transaction.blockNumber?.toString() ?? null,
+    transactionHash: transaction.hash ?? null,
+    transactionIndex: transaction.index?.toString() ?? null
+  };
+}
+function sanitizeTransactionReceipt(transactionReceipt) {
+  if (!transactionReceipt) {
+    return null;
+  }
+  return {
+    status: transactionReceipt.status?.toString() ?? null,
+    blockHash: transactionReceipt.blockHash ?? null,
+    blockNumber: transactionReceipt.blockNumber?.toString() ?? null,
+    transactionHash: transactionReceipt.hash ?? null,
+    transactionIndex: transactionReceipt.index?.toString() ?? null
+  };
+}
+function validateTransactionAccess(transaction, signer) {
+  if (!signer || !transaction) {
+    return false;
+  }
+  const signerLower = signer.toLowerCase();
+  if (transaction.from && transaction.from.toLowerCase() === signerLower) {
+    return true;
+  }
+  if (transaction.to && transaction.to.toLowerCase() === signerLower) {
+    return true;
+  }
+  return false;
+}
+function validateSignerAgainstResponse(transaction, signer) {
+  return validateTransactionAccess(transaction, signer);
+}
+async function handleGetTransactionByHash(provider2, txHash, signer) {
+  const transaction = await provider2.getTransaction(txHash);
+  if (!transaction) {
+    return null;
+  }
+  if (validateSignerAgainstResponse(transaction, signer)) {
+    return transaction;
+  } else {
+    const sanitizedData = sanitizeTransaction(transaction);
+    return sanitizedData;
+  }
+}
+async function handleGetTransactionReceipt(provider2, txHash, signer) {
+  const transaction = await provider2.getTransactionReceipt(txHash);
+  if (!transaction) {
+    return null;
+  }
+  if (validateSignerAgainstResponse(transaction, signer)) {
+    return transaction;
+  } else {
+    const sanitizedData = sanitizeTransactionReceipt(transaction);
+    return sanitizedData;
+  }
+}
+async function validateTransactionMethod(provider2, method, params, signer) {
+  if (!params || !params[0]) {
+    return null;
+  }
+  const txHash = params[0];
+  try {
+    if (method === "eth_getTransactionByHash") {
+      return await handleGetTransactionByHash(provider2, txHash, signer);
+    } else if (method === "eth_getTransactionReceipt") {
+      return await handleGetTransactionReceipt(provider2, txHash, signer);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/middleware.ts
+function errorResponse(id, jsonrpc) {
+  return {
+    id,
+    jsonrpc,
+    error: {
+      code: -1,
+      message: "An error occurred",
+      data: "An error occurred"
+    }
+  };
+}
+function parseRpcRequest(req) {
+  let rpcRequest = null;
+  let bodyString = "";
+  if (req.method !== "POST") {
+    return { rpcRequest: null, bodyString };
+  }
+  try {
+    bodyString = req.body.toString();
+    rpcRequest = JSON.parse(bodyString);
+    req.body = rpcRequest;
+  } catch {
+    return { rpcRequest: null, bodyString };
+  }
+  if (!rpcRequest || typeof rpcRequest !== "object" || !("method" in rpcRequest) || !("id" in rpcRequest) || !("jsonrpc" in rpcRequest)) {
+    return { rpcRequest: null, bodyString };
+  }
+  return {
+    rpcRequest,
+    bodyString
+  };
+}
+function createRpcValidationMiddleware(provider2) {
+  return async (req, res, next) => {
+    const { rpcRequest, bodyString } = parseRpcRequest(req);
+    if (!rpcRequest) {
+      next();
+      return;
+    }
+    const { method, id, jsonrpc, params } = rpcRequest;
+    console.log(`Received request with method: ${method}`);
+    if (!import_silentdatarollup_core2.WHITELISTED_METHODS.includes(method)) {
+      console.log(`Method ${method} is not whitelisted`);
+      return res.status(403).json(errorResponse(id, jsonrpc));
+    }
+    if (!import_silentdatarollup_core2.SIGN_RPC_METHODS.includes(method)) {
+      next();
+      return;
+    }
+    const signer = recoverSigner(
+      req.headers,
+      bodyString
+    );
+    if (["eth_getTransactionByHash", "eth_getTransactionReceipt"].includes(method)) {
+      const transaction = await validateTransactionMethod(
+        provider2,
+        method,
+        params,
+        signer
+      );
+      console.log(`Sending transaction response for method: ${method}`);
+      return res.status(200).json({
+        id,
+        jsonrpc,
+        result: transaction
+      });
+    }
+    if (!validateMethodAccess(method, params, signer)) {
+      console.log(`Failed to validate method access for method: ${method}`);
+      return res.status(403).json(errorResponse(id, jsonrpc));
+    }
+    next();
+  };
+}
+
+// src/index.ts
+var import_silentdatarollup_core3 = require("@appliedblockchain/silentdatarollup-core");
+var CUSTOM_RPC_PORT = process.env.CUSTOM_RPC_PORT || 54321;
+var CUSTOM_RPC_PROXY_URL = process.env.CUSTOM_RPC_PROXY_URL || "http://localhost:8545";
+var provider = new import_ethers2.JsonRpcProvider(CUSTOM_RPC_PROXY_URL);
+var app = (0, import_express.default)();
+app.use((req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "*");
+  res.header("Access-Control-Allow-Credentials", "true");
+  res.header(
+    "Access-Control-Allow-Headers",
+    `Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With, ${import_silentdatarollup_core3.HEADER_TIMESTAMP}, ${import_silentdatarollup_core3.HEADER_SIGNATURE}, ${import_silentdatarollup_core3.HEADER_DELEGATE}, ${import_silentdatarollup_core3.HEADER_DELEGATE_SIGNATURE}, ${import_silentdatarollup_core3.HEADER_EIP712_DELEGATE_SIGNATURE}, ${import_silentdatarollup_core3.HEADER_EIP712_SIGNATURE}`
+  );
+  res.header("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT");
+  if (req.method === "OPTIONS") {
+    return res.sendStatus(204);
+  }
+  next();
+});
+app.use(import_body_parser.default.raw({ type: "*/*" }));
+app.use(createRpcValidationMiddleware(provider));
+app.use(
+  (0, import_http_proxy_middleware.createProxyMiddleware)({
+    target: CUSTOM_RPC_PROXY_URL,
+    changeOrigin: true,
+    on: {
+      proxyReq: (proxyReq, req) => {
+        if (req.body) {
+          const bodyData = JSON.stringify(req.body);
+          console.log(`Proxying request with body: ${bodyData}`);
+          proxyReq.setHeader("Content-Length", Buffer.byteLength(bodyData));
+          proxyReq.write(bodyData);
+        }
+      }
+    }
+  })
+);
+app.disable("x-powered-by");
+app.listen(CUSTOM_RPC_PORT, () => {
+  console.log(`Custom RPC listening at http://localhost:${CUSTOM_RPC_PORT}`);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@appliedblockchain/silentdatarollup-custom-rpc",
+  "version": "1.0.0",
+  "description": "Custom RPC for Silent Data [Rollup]",
+  "author": "Applied Blockchain",
+  "homepage": "https://github.com/appliedblockchain/silent-data-rollup-providers#readme",
+  "keywords": [
+    "ethereum",
+    "provider",
+    "silentdata",
+    "rollup",
+    "custom-rpc"
+  ],
+  "license": "MIT",
+  "repository": "https://github.com/appliedblockchain/silent-data-rollup-providers",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "bin": "dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --clean",
+    "check-exports": "attw --pack . --profile node16",
+    "dev": "concurrently --kill-others-on-fail -s all -p '[{name}]' -n 'HARDHAT,CUSTOM RPC' -c 'bgGreen.bold,bgBlue.bold' 'hardhat node' 'nodemon'",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@appliedblockchain/silentdatarollup-core": "1.0.0",
+    "body-parser": "1.20.3",
+    "dotenv": "16.4.7",
+    "ethers": "6.13.2",
+    "express": "4.21.2",
+    "http-proxy-middleware": "3.0.3"
+  },
+  "devDependencies": {
+    "@types/express": "4.17.21",
+    "@types/node": "22.5.4",
+    "concurrently": "9.1.2",
+    "hardhat": "^0.0.7",
+    "nodemon": "3.0.1",
+    "ts-node": "10.9.2",
+    "typescript": "5.6.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}