@effectstream/runtime 0.100.0

package/src/api/rpc-evm/eip1193.ts

@@ -0,0 +1,920 @@
+import {
+  createAsyncMiddleware,
+  JsonRpcEngine,
+} from "@metamask/json-rpc-engine";
+import {
+  createInvalidParamsError,
+  createMethodNotFoundRpcError,
+  createMethodNotSupportedRpcError,
+  type EvmRpcReturn,
+  type PaimaEvmRpcSchema,
+} from "./rpc-types.ts";
+import {
+  // getBlockByHash,
+  getLatestProcessedBlockHeight,
+} from "@effectstream/db";
+import type { Pool } from "pg";
+import {
+  type EIP1193Parameters,
+  isAddress,
+  type RpcBlock,
+  type RpcError,
+  type RpcTransaction,
+  toHex,
+} from "viem";
+import { Buffer } from "node:buffer";
+import sha3 from "js-sha3";
+import {
+  toRpcBlock,
+  toRpcLog,
+  toRpcTransaction,
+  toRpcTransactionReceipt,
+} from "./rpc-payloads.ts";
+import {
+  isValidBlockHash,
+  isValidHexadecimal,
+  isValidTxHash,
+  strip0x,
+} from "./rpc-utils.ts";
+const { keccak_256 } = sha3;
+import { runPreparedQuery } from "@effectstream/db";
+import { ENV } from "@effectstream/utils/node-env";
+
+export function evmRpcEngine(dbConn: Pool): JsonRpcEngine {
+  const engine = new JsonRpcEngine();
+  // TODO: add cache middleware
+  // registerCacheMiddleware(evmRpcEngine);
+
+  /**
+   * ===============================
+   * JSON-RPC Middleware definitions
+   * ===============================
+   */
+
+  // TODO: Most of these methods are not implemented, or partially implemented.
+  //       Check effectstream-v1 eip1193.ts for the full implementation details.
+  engine.push(
+    createAsyncMiddleware(async (req, res) => {
+      const evmRpc: typeof req & EIP1193Parameters<PaimaEvmRpcSchema> =
+        req as any;
+
+      const setResult = <Method extends string>(
+        result: EvmRpcReturn<Method>,
+      ): void => {
+        res.result = result as any;
+      };
+
+      // TODO: missing these validity checks:
+      // - InvalidInputRpcError / InvalidParamsRpcError
+      switch (evmRpc.method) {
+        /*
+         * ==============
+         * Gossip methods
+         * ==============
+         */
+        case "eth_blockNumber": {
+          const [lastBlockHeight] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_blockNumber",
+          );
+
+          setResult<typeof evmRpc.method>(
+            `0x${lastBlockHeight.block_height.toString(16)}`,
+          );
+          return;
+        }
+        case "eth_sendRawTransaction": {
+          // TODO: we can probably support this
+          //       but supporting this conversion would have to be a Effectstream-level feature and not a EVM-RPC feature
+          res.error = createMethodNotSupportedRpcError(
+            evmRpc.method,
+            `${evmRpc.method} currently unsupported`,
+          );
+          return;
+        }
+
+        /**
+         * =============
+         * State methods
+         * =============
+         */
+
+        case "eth_getBalance": {
+          setResult<typeof evmRpc.method>(
+            `${toHex(BigInt(0))}`,
+          );
+          return;
+        }
+
+        case "eth_getStorageAt": {
+          // not possible in Paima Engine at the moment, but maybe in the future related to precompiles
+          res.error = createMethodNotSupportedRpcError(
+            evmRpc.method,
+            `${evmRpc.method} currently unsupported`,
+          );
+          return;
+        }
+        case "eth_getTransactionCount": {
+          const address = evmRpc.params[0];
+          if (!isAddress(address)) {
+            res.error = createInvalidParamsError(
+              { address },
+              `Address is not a valid Ethereum address`,
+            );
+            return;
+          }
+          let blockHeight: number;
+          // TODO
+          // const blockTag = simplifyBlockTag(evmRpc.params[1] ?? "finalized");
+
+          // if (blockParam == "earliest") return FIRST_BLOCK_HEIGHT;
+          // if (blockParam == "latest") {
+          //   const [lastBlockHeight] = await getLatestProcessedBlockHeight.run(
+          //     undefined,
+          //     dbConn,
+          //   );
+          //   blockHeight = lastBlockHeight.block_height;
+          // }
+
+          // try {
+          //   blockHeight = await toBlockNumber(evmRpc.params[1] ?? "finalized");
+          // } catch (err) {
+          //   res.error = err as RpcError;
+          //   return;
+          // }
+          // const { data, error } = await getPaimaNodeRestClient().GET(
+          //   "/transaction_count/address",
+          //   {
+          //     params: { query: { blockHeight, address } },
+          //   },
+          // );
+          // if (error != null) {
+          //   res.error = createInternalRpcError({}, error?.errorMessage);
+          //   return;
+          // }
+          // if (data.success === false) {
+          //   res.error = createInternalRpcError({}, data.errorMessage);
+          //   return;
+          // }
+          setResult<typeof evmRpc.method>(
+            `0x${
+              Number(0)
+                // (data.result.scheduledData + data.result.submittedInputs)
+                .toString(
+                  16,
+                )
+            }`,
+          );
+          return;
+        }
+        case "eth_getCode": {
+          // not possible in Paima Engine at the moment, but maybe in the future related to precompiles
+          res.error = createMethodNotSupportedRpcError(
+            evmRpc.method,
+            `${evmRpc.method} currently unsupported`,
+          );
+          return;
+        }
+        case "eth_call": {
+          // not possible in Paima Engine at the moment, but maybe in the future related to precompiles
+          res.error = createMethodNotSupportedRpcError(
+            evmRpc.method,
+            `${evmRpc.method} currently unsupported`,
+          );
+          return;
+        }
+        case "eth_estimateGas": {
+          // no concept of gas in Paima (gas is from the underlying chain)
+          setResult<typeof evmRpc.method>(`0x0`);
+          return;
+        }
+
+        /**
+         * ===============
+         * History methods
+         * ===============
+         */
+
+        case "eth_getBlockTransactionCountByHash": {
+          const blockHash = evmRpc.params[0];
+          if (typeof blockHash !== "string" || !isValidBlockHash(blockHash)) {
+            res.error = createInvalidParamsError(
+              { blockHash },
+              `Needs to be a valid block hash (0x...)`,
+            );
+            return;
+          }
+          //     const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/transaction_count/blockHash",
+          //       {
+          //         params: { query: { blockHash: blockHash } },
+          //       },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+          setResult<typeof evmRpc.method>(
+            `0x${
+              Number(0)
+                // (data.result.scheduledData + data.result.submittedInputs)
+                .toString(
+                  16,
+                )
+            }`,
+          );
+          return;
+        }
+        case "eth_getBlockTransactionCountByNumber": {
+          let blockHeight: number;
+          // try {
+          //   blockHeight = await toBlockNumber(evmRpc.params[0] ?? "finalized");
+          // } catch (err) {
+          //   res.error = err as RpcError;
+          //   return;
+          // }
+          // const { data, error } = await getPaimaNodeRestClient().GET(
+          //   "/transaction_count/blockHeight",
+          //   {
+          //     params: { query: { blockHeight } },
+          //   },
+          // );
+          // if (error != null) {
+          //   res.error = createInternalRpcError({}, error?.errorMessage);
+          //   return;
+          // }
+          // if (data.success === false) {
+          //   res.error = createInternalRpcError({}, data.errorMessage);
+          //   return;
+          // }
+          setResult<typeof evmRpc.method>(
+            `0x${
+              Number(0)
+                // (data.result.scheduledData + data.result.submittedInputs)
+                .toString(
+                  16,
+                )
+            }`,
+          );
+          return;
+        }
+        case "eth_getUncleCountByBlockHash": {
+          setResult<typeof evmRpc.method>(`0x0`); // no uncles in Paima
+          return;
+        }
+        case "eth_getUncleCountByBlockNumber": {
+          setResult<typeof evmRpc.method>(`0x0`); // no uncles in Paima
+          return;
+        }
+        case "eth_getBlockByHash": {
+          const blockHash = evmRpc.params[0];
+          if (typeof blockHash !== "string" || !isValidBlockHash(blockHash)) {
+            res.error = createInvalidParamsError(
+              { blockHash },
+              `Needs to be a valid block hash (0x...)`,
+            );
+            return;
+          }
+
+          const transactionDetails = evmRpc.params[1];
+          if (typeof transactionDetails !== "boolean") {
+            res.error = createInvalidParamsError(
+              { transactionDetails },
+              `Transaction details must be specified as a boolean`,
+            );
+            return;
+          }
+
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              // { block_hash: Buffer.from(blockHash.slice(2), "hex") },
+              dbConn,
+            ),
+            "eth_getBlockByHash",
+          );
+
+          if (!block) {
+            res.error = createInvalidParamsError(
+              { blockHash },
+              `Block not found`,
+            );
+            return;
+          }
+          //     const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/block_content/blockHash",
+          //       {
+          //         params: {
+          //           query: {
+          //             blockHash,
+          //             txDetails: transactionDetails ? "full" : "hash",
+          //           },
+          //         },
+          //       },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+          const mockInput = {
+            blockHeight: 0, // block.block_height,
+            blockHash: randomBlockHash(),
+            prevBlockHash: randomBlockHash(),
+            msTimestamp: Date.now(),
+            txs: [],
+          };
+          const mock: RpcBlock = toRpcBlock(mockInput, transactionDetails);
+          setResult<typeof evmRpc.method>(mock);
+          return;
+        }
+        case "eth_getBlockByNumber": {
+          let blockHeight: number;
+          let block;
+          try {
+            // TODO this should be dynamic
+            // TOOD for now just passing the block
+            const [block_] = await runPreparedQuery(
+              getLatestProcessedBlockHeight.run(
+                undefined,
+                dbConn,
+              ),
+              "eth_getBlockByNumber",
+            );
+            block = block_;
+            blockHeight = block.block_height;
+            // blockHeight = await toBlockNumber(evmRpc.params[0] ?? "finalized");
+          } catch (err) {
+            res.error = err as RpcError;
+            return;
+          }
+
+          const transactionDetails = evmRpc.params[1];
+          if (typeof transactionDetails !== "boolean") {
+            res.error = createInvalidParamsError(
+              { transactionDetails },
+              `Transaction details must be specified as a boolean`,
+            );
+            return;
+          }
+
+          // const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/block_content/blockHeight",
+          //       {
+          //         params: {
+          //           query: {
+          //             blockHeight,
+          //             txDetails: transactionDetails ? "full" : "hash",
+          //           },
+          //         },
+          //       },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+
+          // example: 0x1e888a0eadd622fe55b53692139e64f23852b247060fcb31322c3a76b265e760
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+          const mockInput = {
+            blockHeight: block.block_height,
+            blockHash: randomBlockHash(),
+            prevBlockHash: randomBlockHash(),
+            msTimestamp: Date.now(),
+            txs: [],
+          };
+          const mock: RpcBlock = toRpcBlock(mockInput, transactionDetails);
+          setResult<typeof evmRpc.method>(mock);
+          return;
+        }
+        case "eth_getTransactionByHash": {
+          const txHash = evmRpc.params[0];
+          if (!isValidTxHash(txHash)) {
+            res.error = createInvalidParamsError(
+              { txHash },
+              `Transaction hash did not match EVM format: ${txHash}`,
+            );
+            return;
+          }
+          // TODO
+          //     const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/transaction_content/txHash",
+          //       {
+          //         params: { query: { txHash } },
+          //       },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_getTransactionByHash",
+          );
+          if (!block) {
+            res.error = createInvalidParamsError(
+              { txHash },
+              `Block not found`,
+            );
+            return;
+          }
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+          const mockInput = {
+            blockHash: randomBlockHash(),
+            blockNumber: block.block_height,
+            from: randomBlockHash(),
+            inputData: "hello",
+            txHash: txHash,
+            txIndex: 0,
+          };
+          const mock: RpcTransaction = toRpcTransaction(mockInput);
+          setResult<typeof evmRpc.method>(mock);
+          return;
+        }
+        case "eth_getTransactionByBlockHashAndIndex": {
+          const blockHash = evmRpc.params[0];
+          if (typeof blockHash !== "string" || !isValidBlockHash(blockHash)) {
+            res.error = createInvalidParamsError(
+              { blockHash },
+              `Needs to be a valid block hash (0x...)`,
+            );
+            return;
+          }
+          //     const txIndex = Number.parseInt(evmRpc.params[1], 16);
+          //     if (typeof txIndex !== "number") {
+          //       res.error = createInvalidParamsError(
+          //         { txIndex },
+          //         `Transaction index must be specified as a number`,
+          //       );
+          //       return;
+          //     }
+
+          //     const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/transaction_content/blockHashAndIndex",
+          //       { params: { query: { blockHash, txIndex } } },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_getTransactionByBlockHashAndIndex",
+          );
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+          const mockInput = {
+            blockHash: randomBlockHash(),
+            blockNumber: block.block_height,
+            from: randomBlockHash(),
+            inputData: randomBlockHash(),
+            txHash: randomBlockHash(),
+            txIndex: 0,
+          };
+          const mock = toRpcTransaction(mockInput);
+          setResult<typeof evmRpc.method>(mock);
+          return;
+        }
+        case "eth_getTransactionByBlockNumberAndIndex": {
+          let blockHeight: number;
+          try {
+            const [block] = await runPreparedQuery(
+              getLatestProcessedBlockHeight.run(
+                undefined,
+                dbConn,
+              ),
+              "eth_getTransactionByBlockNumberAndIndex",
+            );
+            blockHeight = block.block_height;
+            // blockHeight = await toBlockNumber(evmRpc.params[0]);
+          } catch (err) {
+            res.error = err as RpcError;
+            return;
+          }
+          const txIndex = Number.parseInt(evmRpc.params[1], 16);
+          if (typeof txIndex !== "number") {
+            res.error = createInvalidParamsError(
+              { txIndex },
+              `Transaction index must be specified as a number`,
+            );
+            return;
+          }
+
+          //     const { data, error } = await getPaimaNodeRestClient().GET(
+          //       "/transaction_content/blockNumberAndIndex",
+          //       { params: { query: { blockHeight, txIndex } } },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_getTransactionByBlockNumberAndIndex",
+          );
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+          const mockInput = {
+            blockHash: randomBlockHash(),
+            blockNumber: block.block_height,
+            from: randomBlockHash(),
+            inputData: randomBlockHash(),
+            txHash: randomBlockHash(),
+            txIndex: 0,
+          };
+          const mock = toRpcTransaction(mockInput);
+          setResult<typeof evmRpc.method>(mock);
+          return;
+        }
+        case "eth_getLogs": {
+          const request = evmRpc.params[0];
+
+          let fromBlock: number;
+          let toBlock: number;
+          //     if (request.blockHash) {
+          //       if (
+          //         typeof request.blockHash !== "string" ||
+          //         !isValidBlockHash(request.blockHash)
+          //       ) {
+          //         res.error = createInvalidParamsError(
+          //           { blockHash: request.blockHash },
+          //           `Needs to be a valid block hash (0x...)`,
+          //         );
+          //         return;
+          //       }
+          //       const { data, error } = await getPaimaNodeRestClient().GET(
+          //         "/block_content/blockHash",
+          //         {
+          //           params: {
+          //             query: { blockHash: request.blockHash, txDetails: "none" },
+          //           },
+          //         },
+          //       );
+          //       if (error != null) {
+          //         res.error = createInternalRpcError({}, error?.errorMessage);
+          //         return;
+          //       }
+          //       if (data.success === false) {
+          //         res.error = createInternalRpcError({}, data.errorMessage);
+          //         return;
+          //       }
+
+          //       fromBlock = data.result.blockHeight;
+          //       toBlock = data.result.blockHeight;
+          //     } else {
+          //       try {
+          //         fromBlock = await toBlockNumber(request.fromBlock ?? "latest");
+          //       } catch (err) {
+          //         res.error = err as RpcError;
+          //         return;
+          //       }
+          //       try {
+          //         toBlock = await toBlockNumber(request.toBlock ?? "latest");
+          //       } catch (err) {
+          //         res.error = err as RpcError;
+          //         return;
+          //       }
+          //     }
+
+          // const filterFields: Partial<
+          //   Pick<
+          //     PaimaNodeRestComponents["schemas"]["GetLogsParams"],
+          //     "filters" | "topic"
+          //   >
+          // > = {};
+          //     if (request.topics != null && request.topics.length > 0) {
+          //       // https://ethereum.stackexchange.com/a/107326/140076
+          //       // problem: how do we know if something is an address, or a string that happens to be the same length?
+          //       const [topicHash, ...data] = request.topics;
+          //       filterFields.topic = strip0x(topicHash as string);
+
+          //       // we need to map any other data provided from EVM format to Paima format
+          //       if (data.length > 0) {
+          //         const eventDefinition = (():
+          //           | undefined
+          //           | RegisteredEvent<LogEvent<LogEventFields<TSchema>[]>> => {
+          //           const appEvents = EngineService.INSTANCE.getSM().getAppEvents();
+
+          //           for (const defs of Object.values(appEvents)) {
+          //             for (const def of defs) {
+          //               if (def.topicHash === filterFields.topic) {
+          //                 return def;
+          //               }
+          //             }
+          //           }
+
+          //           return undefined;
+          //         })();
+
+          //         // if no event is found for this topic, we can just return right away
+          //         // note: EVM RPCs also do not return an error for not-found topics, as they may be registered later
+          //         if (eventDefinition == null) {
+          //           setResult<typeof evmRpc.method>([]);
+          //           return;
+          //         }
+
+          //         const eventPaths = eventDefinition.path as EventPath;
+          //         const evmAbi = toEvmAbi(eventDefinition.definition);
+          //         if (evmAbi == null) {
+          //           res.error = createInternalRpcError(
+          //             {},
+          //             `EVM ABI conversion for this event type is not supported`,
+          //           );
+          //           return;
+          //         }
+          //         for (let i = 0, j = 0; i < data.length; i++) {
+          //           const topic = data[i];
+          //           if (topic == null) continue;
+          //           if (Array.isArray(topic)) {
+          //             res.error = createInvalidParamsError(
+          //               { topic },
+          //               `Array-style OR topics unsupported at the moment`,
+          //             );
+          //             return;
+          //           }
+          //           let nextFilter: undefined | ArgPath = undefined;
+          //           // increase `j` to the index of the next filter for this event
+          //           for (; j < eventPaths.length; j++) {
+          //             let path = eventPaths[j];
+          //             if (typeof path !== "string") {
+          //               nextFilter = path;
+          //               break;
+          //             }
+          //           }
+          //           // no fields left (there are more event RPC filters specified than fields for this event)
+          //           if (nextFilter == null) {
+          //             break;
+          //           }
+          //           const filter = eventPaths[j] as ArgPath;
+
+          //           if (filterFields.filters == null) {
+          //             filterFields.filters = {};
+          //           }
+          //           filterFields.filters[filter.name] = decodeAbiParameters(
+          //             [evmAbi[i]],
+          //             topic,
+          //           )[0] as string;
+          //         }
+          //       }
+          //     }
+
+          //     const { data, error } = await getPaimaNodeRestClient().POST(
+          //       "/get_logs",
+          //       {
+          //         body: {
+          //           fromBlock,
+          //           toBlock,
+          //           ...filterFields,
+          //           address: request.address,
+          //         },
+          //       },
+          //     );
+          //     if (error != null) {
+          //       res.error = createInternalRpcError({}, error?.errorMessage);
+          //       return;
+          //     }
+          //     if (data.success === false) {
+          //       res.error = createInternalRpcError({}, data.errorMessage);
+          //       return;
+          //     }
+
+          setResult<typeof evmRpc.method>([].map(toRpcLog));
+          return;
+        }
+        case "eth_getTransactionReceipt": {
+          const txHash = evmRpc.params[0];
+          if (!isValidTxHash(txHash)) {
+            res.error = createInvalidParamsError(
+              { txHash },
+              `Transaction hash did not match EVM format: ${txHash}`,
+            );
+            return;
+          }
+
+          //     const { data: txData, error: txError } = await getPaimaNodeRestClient()
+          //       .GET(
+          //         "/transaction_content/txHash",
+          //         {
+          //           params: { query: { txHash } },
+          //         },
+          //       );
+          //     if (txError != null) {
+          //       res.error = createInternalRpcError({}, txError?.errorMessage);
+          //       return;
+          //     }
+          //     if (txData.success === false) {
+          //       res.error = createInternalRpcError({}, txData.errorMessage);
+          //       return;
+          //     }
+
+          //     // TODO: create a version of get_logs for specific transactions
+
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_getTransactionReceipt",
+          );
+
+          if (!block) {
+            res.error = createInvalidParamsError(
+              { txHash },
+              `Block not found`,
+            );
+            return;
+          }
+
+          const randomBlockHash = (): string =>
+            "0x" +
+            Array(64).fill(0).map(() =>
+              Math.floor(Math.random() * 16).toString(16)
+            ).join("");
+
+          const mockInput = {
+            result: {
+              txHash: randomBlockHash(),
+              blockHash: randomBlockHash(),
+              blockNumber: block.block_height,
+              txIndex: 0,
+              from: randomBlockHash(),
+              success: true,
+            },
+          };
+          setResult<typeof evmRpc.method>(toRpcTransactionReceipt(mockInput));
+          return;
+        }
+        case "eth_getUncleByBlockHashAndIndex": {
+          setResult<typeof evmRpc.method>(null); // no uncles in Paima
+          return;
+        }
+        case "eth_getUncleByBlockNumberAndIndex": {
+          setResult<typeof evmRpc.method>(null); // no uncles in Paima
+          return;
+        }
+
+        //   /**
+        //    * ===============
+        //    * Other methods
+        //    * ===============
+        //    */
+
+        case "web3_clientVersion": {
+          // TODO: should include the following
+          // 1: commit hash somehow
+          // 2: platform
+          // 3: node version
+          // example of Geth: Geth/v1.9.15-stable-0f77f34b/linux-amd64/go1.14.4"
+          // we just keep it simple for now
+          // TODO: UPDATE THIS
+          setResult<typeof evmRpc.method>(
+            `PaimaEngine/v0.0.1`,
+          );
+          return;
+        }
+        case "web3_sha3": {
+          const data = evmRpc.params[0];
+          if (typeof data !== "string" || !isValidHexadecimal(strip0x(data))) {
+            res.error = createInvalidParamsError(
+              { data },
+              `Data must be a hex-encoded string 0x...`,
+            );
+            return;
+          }
+          // web3_sha3 passes the data as a hex-string, so we need to convert it
+          const buffer = Buffer.from(strip0x(data), "hex");
+
+          setResult<typeof evmRpc.method>(`0x${keccak_256(buffer as any)}`);
+          return;
+        }
+        case "net_version": {
+          // net_version is an older version of eth_chainId that predates the ETC hardfork
+          // eth_chainId should always be used instead, but net_version===eth_chainId in almost all networks
+          // the only real notable exception being ETC where these values are not equal
+          // learn more: https://medium.com/@pedrouid/chainid-vs-networkid-how-do-they-differ-on-ethereum-eec2ed41635b
+          setResult<typeof evmRpc.method>(
+            `0x${ENV.EFFECTSTREAM_CHAIN_ID.toString(16)}`,
+          );
+          return;
+        }
+        case "net_listening": {
+          // note: depending on your interpretation,
+          //       this should one of
+          //       A) always return true (is the server online at all)
+          //       B) Only return true if this RPC should be used by others (is one RPC better than another)
+          //       C) Can you sync blocks from connecting to this node
+          //       ex: in wagmi, it's used to rank multiple RPCs and it prioritizes RPCs that return true
+          setResult<typeof evmRpc.method>(true); // maybe this should be ENV.SERVER_ONLY_MODE
+          return;
+        }
+        case "net_peerCount": {
+          // todo: theoretically we could support this based on MQTT connections or something similar, but it's not worth it
+          setResult<typeof evmRpc.method>(`0x0`);
+          return;
+        }
+        case "eth_gasPrice": {
+          // no concept of gas in Paima (gas is from the underlying chain)
+          setResult<typeof evmRpc.method>(`0x0`);
+          return;
+        }
+        case "eth_chainId": {
+          // TODO: this is not a great thing to return, since every game is its own chain. Not sure what to do about this
+          //       maybe the hash of the game name or something?
+          setResult<typeof evmRpc.method>(
+            `0x${ENV.EFFECTSTREAM_CHAIN_ID.toString(16)}`,
+          );
+          return;
+        }
+
+        case "eth_syncing": {
+          // if (ENV.SERVER_ONLY_MODE) {
+          //   setResult<typeof evmRpc.method>(false);
+          // }
+          // const { data, error } = await getPaimaNodeRestClient().GET(
+          //   "/latest_processed_blockheight",
+          // );
+          // if (error != null) {
+          //   res.error = createInternalRpcError({}, error?.errorMessage);
+          //   return;
+          // }
+
+          const [block] = await runPreparedQuery(
+            getLatestProcessedBlockHeight.run(
+              undefined,
+              dbConn,
+            ),
+            "eth_syncing",
+          );
+
+          // TODO Updaste this
+          const ENV_START_BLOCKHEIGHT = 0;
+          setResult<typeof evmRpc.method>({
+            startingBlock: `0x${ENV_START_BLOCKHEIGHT.toString(16)}`,
+            currentBlock: `0x${block.block_height.toString(16)}`,
+          });
+          return;
+        }
+
+        default: {
+          res.error = createMethodNotFoundRpcError(evmRpc.method);
+        }
+      }
+    }),
+  );
+
+  return engine;
+}