add wiresaw transport

Author: frolic

packages/entrykit/src/createWagmiConfig.ts

@@ -2,6 +2,8 @@ import { Chain, Transport } from "viem";
 import { connectorsForWallets } from "@rainbow-me/rainbowkit";
 import { Config, CreateConfigParameters, createConfig } from "wagmi";
 import { getWallets } from "./getWallets";
+import { mapObject } from "@latticexyz/common/utils";
+import { wiresaw } from "./quarry/transports/wiresaw";
 
 export type CreateWagmiConfigOptions<
   chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]],
@@ -27,11 +29,12 @@ export function createWagmiConfig<
     appName: config.appName,
     projectId: config.walletConnectProjectId,
   });
+  const transports = mapObject(config.transports, (transport) => wiresaw(transport));
 
   return createConfig({
     connectors,
     chains: config.chains,
-    transports: config.transports,
+    transports,
     pollingInterval: config.pollingInterval,
   }) as never;
 }

packages/entrykit/src/getBundlerTransport.ts

@@ -2,12 +2,18 @@ import { transactionQueue } from "@latticexyz/common/actions";
 import { Chain, Client, Transport, createClient, http, keccak256, stringToHex } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { userOpExecutor } from "./quarry/transports/userOpExecutor";
+import { wiresaw } from "./quarry/transports/wiresaw";
 
 export function getBundlerTransport(client: Client<Transport, Chain>) {
   const bundlerHttpUrl = client.chain.rpcUrls.bundler?.http[0];
   // TODO: bundler websocket
+  // TODO: do chain checks/conditionals inside the transports
   const bundlerTransport = bundlerHttpUrl
-    ? alto(http(bundlerHttpUrl))
+    ? client.chain.id === 17420
+      ? wiresaw(http(bundlerHttpUrl))
+      : client.chain.id === 690 || client.chain.id === 17069
+        ? alto(http(bundlerHttpUrl))
+        : http(bundlerHttpUrl)
     : client.chain.id === 31337
       ? userOpExecutor({
           executor: createClient({
@@ -24,7 +30,7 @@ export function getBundlerTransport(client: Client<Transport, Chain>) {
   return bundlerTransport;
 }
 
-export function alto<transport extends Transport>(createTransport: transport): transport {
+function alto<transport extends Transport>(createTransport: transport): transport {
   return ((opts) => {
     const transport = createTransport(opts);
     const request: typeof transport.request = async (req) => {

packages/entrykit/src/quarry/transports/wiresaw.ts

@@ -0,0 +1,161 @@
+import {
+  BundlerRpcSchema,
+  Hash,
+  Hex,
+  PublicRpcSchema,
+  RpcTransactionReceipt,
+  RpcUserOperationReceipt,
+  Transport,
+  fallback,
+  http,
+  webSocket,
+} from "viem";
+import { getRpcMethod, getRpcSchema, TransportRequestFn, TransportRequestFnMapped } from "./common";
+
+export type WiresawRpcSchema = [
+  {
+    Method: "wiresaw_call";
+    Parameters: getRpcMethod<PublicRpcSchema, "eth_call">["Parameters"];
+    ReturnType: getRpcMethod<PublicRpcSchema, "eth_call">["ReturnType"];
+  },
+  {
+    Method: "wiresaw_getTransactionReceipt";
+    Parameters: getRpcMethod<PublicRpcSchema, "eth_getTransactionReceipt">["Parameters"];
+    ReturnType: getRpcMethod<PublicRpcSchema, "eth_getTransactionReceipt">["ReturnType"];
+  },
+  {
+    Method: "wiresaw_sendUserOperation";
+    Parameters: getRpcMethod<BundlerRpcSchema, "eth_sendUserOperation">["Parameters"];
+    ReturnType: {
+      userOpHash: Hex;
+      txHash: Hex;
+    };
+  },
+];
+
+export type OverriddenMethods = [
+  ...getRpcSchema<PublicRpcSchema, "eth_chainId" | "eth_call" | "eth_getTransactionReceipt">,
+  ...getRpcSchema<BundlerRpcSchema, "eth_sendUserOperation" | "eth_getUserOperationReceipt">,
+];
+
+type ChainCache = {
+  receipts: Map<Hash, RpcTransactionReceipt>;
+  /**
+   * user op hash to transaction hash
+   */
+  userOps: Map<Hash, Hash>;
+};
+
+const cache = new Map<Hex, ChainCache>();
+
+function getCache(chainId: Hex) {
+  const cached = cache.get(chainId) ?? {
+    receipts: new Map<Hash, RpcTransactionReceipt>(),
+    userOps: new Map<Hash, Hash>(),
+  };
+  if (!cache.has(chainId)) cache.set(chainId, cached);
+  return cached;
+}
+
+export function wiresaw<const transport extends Transport>(getTransport: transport): transport {
+  return ((args) => {
+    const getWiresawTransport =
+      args.chain?.rpcUrls && "wiresaw" in args.chain.rpcUrls
+        ? args.chain.rpcUrls.wiresaw.webSocket
+          ? fallback([webSocket(args.chain.rpcUrls.wiresaw.webSocket[0]), http(args.chain.rpcUrls.wiresaw.http[0])])
+          : http(args.chain.rpcUrls.wiresaw.http[0])
+        : undefined;
+    if (!getWiresawTransport) return getTransport(args);
+
+    const transport = getTransport(args) as {
+      request: TransportRequestFn<OverriddenMethods>;
+    };
+    const wiresawTransport = getWiresawTransport(args) as {
+      request: TransportRequestFn<WiresawRpcSchema>;
+    };
+
+    let chainId: Hex | null = null;
+    async function getChainId() {
+      return (chainId ??= await transport.request({ method: "eth_chainId" }));
+    }
+
+    async function getReceipt(hash: Hex, receipts: ChainCache["receipts"]) {
+      if (receipts.has(hash)) return receipts.get(hash)!;
+      const [wiresawReceipt, chainReceipt] = await Promise.all([
+        wiresawTransport.request({
+          method: "wiresaw_getTransactionReceipt",
+          params: [hash],
+        }),
+        transport.request({
+          method: "eth_getTransactionReceipt",
+          params: [hash],
+        }),
+      ]);
+      const receipt = wiresawReceipt ?? chainReceipt;
+      if (receipt != null) receipts.set(hash, receipt);
+      return receipt;
+    }
+
+    const request: TransportRequestFnMapped<OverriddenMethods> = async ({ method, params }, opts) => {
+      if (method === "eth_chainId") {
+        return await getChainId();
+      }
+
+      // TODO: only route to wiresaw if using pending block tag
+      if (method === "eth_call") {
+        return wiresawTransport.request({ method: "wiresaw_call", params });
+      }
+
+      // We intentionally don't reroute `eth_sendRawTransaction` because Wiresaw
+      // already handles this method within the RPC spec, where it returns the
+      // tx hash, which can be fetched immediately with `eth_getTransactionReceipt`.
+
+      if (method === "eth_getTransactionReceipt") {
+        const { receipts } = getCache(await getChainId());
+        const [hash] = params;
+        return await getReceipt(hash, receipts);
+      }
+
+      if (method === "eth_sendUserOperation") {
+        const { userOps } = getCache(await getChainId());
+        const result = await wiresawTransport.request({
+          method: "wiresaw_sendUserOperation",
+          params,
+        });
+        userOps.set(result.userOpHash, result.txHash);
+        return result.userOpHash;
+      }
+
+      if (method === "eth_getUserOperationReceipt") {
+        const { userOps } = getCache(await getChainId());
+        const [userOpHash] = params;
+        const transactionHash = userOps.get(userOpHash);
+
+        if (!transactionHash) {
+          // TODO: look up user op logs
+          // https://github.com/latticexyz/alto/blob/206dd8fc0d672a3d49e06d4bdd2eff4d519bdea3/src/executor/executorManager.ts#L617-L625
+          throw new Error(`Could not find transaction hash for user op hash "${userOpHash}".`);
+        }
+
+        // return instant/partial receipt for now until we can find a good way
+        // to opt-in to this when using things like permissionless actions, which
+        // call out to `waitForUserOperationReceipt`
+        return {
+          success: true,
+          userOpHash,
+          receipt: {
+            transactionHash,
+          },
+        } as RpcUserOperationReceipt;
+
+        // const receipt = await getReceipt(transactionHash, receipts);
+        // if (!receipt) return null;
+        // return getUserOperationReceipt(userOpHash, receipt);
+      }
+
+      return await transport.request({ method, params }, opts);
+    };
+
+    return { ...transport, request };
+  }) as transport;
+}