@latticexyz/entrykit 2.2.22-9f06079cb52cb39888097ea3a293ec71bd46ebbc → 2.2.22-a397ec2827f0b55f9f5b685a660295467d32c0c5

package/dist/tsup/exports/internal.js

@@ -188,21 +188,168 @@ function userOpExecutor({ executor }) {
   };
 }
 
+// src/quarry/transports/methods/getUserOperationReceipt.ts
+import {
+  decodeEventLog,
+  encodeEventTopics,
+  numberToHex as numberToHex2,
+  parseEventLogs as parseEventLogs2,
+  zeroAddress
+} from "viem";
+import { entryPoint07Abi as entryPoint07Abi2 } from "viem/account-abstraction";
+var userOperationRevertReasonAbi = [
+  entryPoint07Abi2.find(
+    (item) => item.type === "event" && item.name === "UserOperationRevertReason"
+  )
+];
+var userOperationEventTopic = encodeEventTopics({
+  abi: entryPoint07Abi2,
+  eventName: "UserOperationEvent"
+});
+function getUserOperationReceipt(userOpHash, receipt) {
+  const userOperationRevertReasonTopicEvent = encodeEventTopics({
+    abi: userOperationRevertReasonAbi
+  })[0];
+  let entryPoint = zeroAddress;
+  let revertReason = void 0;
+  let startIndex = -1;
+  let endIndex = -1;
+  receipt.logs.forEach((log, index) => {
+    if (log?.topics[0] === userOperationEventTopic[0]) {
+      if (log.topics[1] === userOpHash) {
+        endIndex = index;
+        entryPoint = log.address;
+      } else if (endIndex === -1) {
+        startIndex = index;
+      }
+    }
+    if (log?.topics[0] === userOperationRevertReasonTopicEvent) {
+      if (log.topics[1] === userOpHash) {
+        const decodedLog = decodeEventLog({
+          abi: userOperationRevertReasonAbi,
+          data: log.data,
+          topics: log.topics
+        });
+        revertReason = decodedLog.args.revertReason;
+      }
+    }
+  });
+  if (endIndex === -1) {
+    throw new Error("fatal: no UserOperationEvent in logs");
+  }
+  const logs = receipt.logs.slice(startIndex + 1, endIndex);
+  const userOperationEvent = parseEventLogs2({
+    abi: entryPoint07Abi2,
+    eventName: "UserOperationEvent",
+    args: {
+      userOpHash
+    },
+    logs: receipt.logs
+  })[0];
+  let paymaster = userOperationEvent.args.paymaster;
+  paymaster = paymaster === zeroAddress ? void 0 : paymaster;
+  return {
+    userOpHash,
+    entryPoint,
+    sender: userOperationEvent.args.sender,
+    nonce: numberToHex2(userOperationEvent.args.nonce),
+    paymaster,
+    actualGasUsed: numberToHex2(userOperationEvent.args.actualGasUsed),
+    actualGasCost: numberToHex2(userOperationEvent.args.actualGasCost),
+    success: userOperationEvent.args.success,
+    reason: revertReason,
+    logs,
+    receipt
+  };
+}
+
+// src/quarry/transports/wiresaw.ts
+function wiresaw(transport) {
+  return (opts) => {
+    const { request: originalRequest, ...rest } = transport.wiresaw(opts);
+    let chainId = null;
+    const transactionHashes = {};
+    const transactionReceipts = {};
+    return {
+      ...rest,
+      async request(req) {
+        if (req.method === "eth_chainId") {
+          if (chainId != null) return chainId;
+          return chainId = await originalRequest(req);
+        }
+        if (req.method === "eth_estimateGas") {
+          return originalRequest({ ...req, method: "wiresaw_estimateGas" });
+        }
+        if (req.method === "eth_call") {
+          return originalRequest({ ...req, method: "wiresaw_call" });
+        }
+        if (req.method === "eth_getTransactionCount") {
+          return originalRequest({ ...req, method: "wiresaw_getTransactionCount" });
+        }
+        if (req.method === "eth_getTransactionReceipt") {
+          const transactionHash = req.params[0];
+          const receipt = transactionReceipts[transactionHash] ?? await originalRequest(req);
+          transactionReceipts[transactionHash] ??= receipt;
+          return receipt;
+        }
+        if (req.method === "eth_sendUserOperation") {
+          const { userOpHash, txHash } = await originalRequest({
+            ...req,
+            method: "wiresaw_sendUserOperation"
+          });
+          transactionHashes[userOpHash] = txHash;
+          return userOpHash;
+        }
+        if (req.method === "eth_getUserOperationReceipt") {
+          const userOpHash = req.params[0];
+          const knownTransactionHash = transactionHashes[userOpHash];
+          if (knownTransactionHash) {
+            const transactionReceipt = transactionReceipts[knownTransactionHash] ?? await originalRequest({
+              ...req,
+              params: [knownTransactionHash],
+              method: "eth_getTransactionReceipt"
+            });
+            transactionReceipts[knownTransactionHash] ??= transactionReceipt;
+            return transactionReceipt && getUserOperationReceipt(userOpHash, transactionReceipt);
+          }
+          const { request: fallbackRequest } = transport.fallbackBundler(opts);
+          return fallbackRequest(req);
+        }
+        if (req.method === "eth_estimateUserOperationGas") {
+          const { request: fallbackRequest } = transport.fallbackBundler(opts);
+          return fallbackRequest(req);
+        }
+        return originalRequest(req);
+      }
+    };
+  };
+}
+
 // src/getBundlerTransport.ts
 function getBundlerTransport(chain) {
   const bundlerHttpUrl = chain.rpcUrls.bundler?.http[0];
-  const bundlerTransport = bundlerHttpUrl ? http(bundlerHttpUrl) : chain.id === 31337 ? userOpExecutor({
-    executor: createClient({
-      chain,
-      transport: fallback([webSocket(), http()]),
-      account: privateKeyToAccount(keccak256(stringToHex("local user op executor"))),
-      pollingInterval: 10
-    }).extend(transactionQueue())
-  }) : null;
-  if (!bundlerTransport) {
-    throw new Error(`Chain ${chain.id} config did not include a bundler RPC URL.`);
+  const wiresawWebSocketUrl = chain.rpcUrls.wiresaw?.webSocket?.[0];
+  if (wiresawWebSocketUrl) {
+    return wiresaw({ wiresaw: webSocket(wiresawWebSocketUrl), fallbackBundler: http(bundlerHttpUrl) });
+  }
+  const wiresawHttpUrl = chain.rpcUrls.wiresaw?.http[0];
+  if (wiresawHttpUrl) {
+    return wiresaw({ wiresaw: http(wiresawHttpUrl), fallbackBundler: http(bundlerHttpUrl) });
+  }
+  if (bundlerHttpUrl) {
+    return http(bundlerHttpUrl);
+  }
+  if (chain.id === 31337) {
+    return userOpExecutor({
+      executor: createClient({
+        chain,
+        transport: fallback([webSocket(), http()]),
+        account: privateKeyToAccount(keccak256(stringToHex("local user op executor"))),
+        pollingInterval: 10
+      }).extend(transactionQueue())
+    });
   }
-  return bundlerTransport;
+  throw new Error(`Chain ${chain.id} config did not include a bundler RPC URL.`);
 }
 
 // src/EntryKitConfigProvider.tsx
@@ -585,7 +732,7 @@ import { useClient } from "wagmi";
 import { queryOptions, skipToken, useQuery as useQuery2 } from "@tanstack/react-query";
 
 // src/quarry/getAllowance.ts
-import { numberToHex as numberToHex2 } from "viem";
+import { numberToHex as numberToHex3 } from "viem";
 
 // src/quarry/common.ts
 import { defineStore } from "@latticexyz/store";
@@ -689,7 +836,7 @@ async function setAllowanceSlot({ client, userAddress, allowance }) {
     {
       address: paymaster.address,
       index: slot,
-      value: numberToHex2(allowance, { size: 32 })
+      value: numberToHex3(allowance, { size: 32 })
     }
   );
 }