thirdweb 5.105.21 → 5.105.23

package/src/wallets/coinbase/coinbase-web.ts

@@ -14,8 +14,16 @@ import {
   stringToHex,
   uint8ArrayToHex,
 } from "../../utils/encoding/hex.js";
+import { stringify } from "../../utils/json.js";
 import { parseTypedData } from "../../utils/signatures/helpers/parse-typed-data.js";
 import { COINBASE } from "../constants.js";
+import { toGetCallsStatusResponse } from "../eip5792/get-calls-status.js";
+import { toGetCapabilitiesResult } from "../eip5792/get-capabilities.js";
+import { toProviderCallParams } from "../eip5792/send-calls.js";
+import type {
+  GetCallsStatusRawResponse,
+  WalletCapabilities,
+} from "../eip5792/types.js";
 import type {
   Account,
   SendTransactionOption,
@@ -269,6 +277,64 @@ function createAccount({
       }
       return res;
     },
+    sendCalls: async (options) => {
+      try {
+        const { callParams, chain } = await toProviderCallParams(
+          options,
+          account,
+        );
+        const callId = await provider.request({
+          method: "wallet_sendCalls",
+          params: callParams,
+        });
+        if (callId && typeof callId === "object" && "id" in callId) {
+          return { chain, client, id: callId.id as string };
+        }
+        return { chain, client, id: callId as string };
+      } catch (error) {
+        if (/unsupport|not support/i.test((error as Error).message)) {
+          throw new Error(
+            `${COINBASE} errored calling wallet_sendCalls, with error: ${error instanceof Error ? error.message : stringify(error)}`,
+          );
+        }
+        throw error;
+      }
+    },
+    async getCallsStatus(options) {
+      try {
+        const rawResponse = (await provider.request({
+          method: "wallet_getCallsStatus",
+          params: [options.id],
+        })) as GetCallsStatusRawResponse;
+        return toGetCallsStatusResponse(rawResponse);
+      } catch (error) {
+        if (/unsupport|not support/i.test((error as Error).message)) {
+          throw new Error(
+            `${COINBASE} does not support wallet_getCallsStatus, reach out to them directly to request EIP-5792 support.`,
+          );
+        }
+        throw error;
+      }
+    },
+    async getCapabilities(options) {
+      const chainId = options.chainId;
+      try {
+        const result = (await provider.request({
+          method: "wallet_getCapabilities",
+          params: [getAddress(account.address)],
+        })) as Record<string, WalletCapabilities>;
+        return toGetCapabilitiesResult(result, chainId);
+      } catch (error: unknown) {
+        if (
+          /unsupport|not support|not available/i.test((error as Error).message)
+        ) {
+          return {
+            message: `${COINBASE} does not support wallet_getCapabilities, reach out to them directly to request EIP-5792 support.`,
+          };
+        }
+        throw error;
+      }
+    },
   };
 
   return account;

package/src/wallets/create-wallet.ts

@@ -2,8 +2,10 @@ import { trackConnect } from "../analytics/track/connect.js";
 import type { Chain } from "../chains/types.js";
 import { getCachedChainIfExists } from "../chains/utils.js";
 import { webLocalStorage } from "../utils/storage/webStorage.js";
+import { formatWalletConnectUrl } from "../utils/url.js";
 import { isMobile } from "../utils/web/isMobile.js";
 import { openWindow } from "../utils/web/openWindow.js";
+import { getWalletInfo } from "./__generated__/getWalletInfo.js";
 import type {
   InjectedSupportedWalletIds,
   WCSupportedWalletIds,
@@ -313,43 +315,63 @@ export function createWallet<const ID extends WalletId>(
                   ...wcOptions,
                   walletConnect: {
                     ...wcOptions.walletConnect,
-                    onDisplayUri: wcOptions.walletConnect?.showQrModal
-                      ? async (uri) => {
-                          // Check if we're in a browser environment
-                          if (
-                            typeof window !== "undefined" &&
-                            typeof document !== "undefined"
-                          ) {
-                            try {
-                              const { createQROverlay } = await import(
-                                "./wallet-connect/qr-overlay.js"
+                    onDisplayUri:
+                      wcOptions.walletConnect?.onDisplayUri ||
+                      (async (uri) => {
+                        // Check if we're in a browser environment
+                        if (
+                          typeof window !== "undefined" &&
+                          typeof document !== "undefined"
+                        ) {
+                          // on mobile, open the wallet app via deeplink
+                          if (isMobile()) {
+                            const walletInfo = await getWalletInfo(id);
+
+                            const mobileAppLink =
+                              walletInfo.mobile.native ||
+                              walletInfo.mobile.universal;
+                            if (mobileAppLink) {
+                              openWindow(
+                                formatWalletConnectUrl(mobileAppLink, uri)
+                                  .redirect,
                               );
+                            } else {
+                              // on android, wc:// links show the app picker
+                              openWindow(uri);
+                            }
+                            return;
+                          }
 
-                              // Clean up any existing overlay
-                              if (qrOverlay) {
-                                qrOverlay.destroy();
-                              }
+                          try {
+                            // on desktop, create a QR overlay
+                            const { createQROverlay } = await import(
+                              "./wallet-connect/qr-overlay.js"
+                            );
 
-                              // Create new QR overlay
-                              qrOverlay = createQROverlay(uri, {
-                                theme:
-                                  wcOptions.walletConnect?.qrModalOptions
-                                    ?.themeMode ?? "dark",
-                                qrSize: 280,
-                                showCloseButton: true,
-                                onCancel: () => {
-                                  wcOptions.walletConnect?.onCancel?.();
-                                },
-                              });
-                            } catch (error) {
-                              console.error(
-                                "Failed to create QR overlay:",
-                                error,
-                              );
+                            // Clean up any existing overlay
+                            if (qrOverlay) {
+                              qrOverlay.destroy();
                             }
+
+                            // Create new QR overlay
+                            qrOverlay = createQROverlay(uri, {
+                              theme:
+                                wcOptions.walletConnect?.qrModalOptions
+                                  ?.themeMode ?? "dark",
+                              qrSize: 280,
+                              showCloseButton: true,
+                              onCancel: () => {
+                                wcOptions.walletConnect?.onCancel?.();
+                              },
+                            });
+                          } catch (error) {
+                            console.error(
+                              "Failed to create QR overlay:",
+                              error,
+                            );
                           }
                         }
-                      : undefined,
+                      }),
                   },
                 },
                 emitter,

package/src/wallets/eip5792/get-calls-status.test.ts

@@ -6,77 +6,12 @@ import { METAMASK } from "../constants.js";
 import { createWallet } from "../create-wallet.js";
 import type { Wallet } from "../interfaces/wallet.js";
 import { getCallsStatus } from "./get-calls-status.js";
-import { type SendCallsOptions, sendCalls } from "./send-calls.js";
-
-const RAW_UNSUPPORTED_ERROR = {
-  code: -32601,
-  message: "some nonsense the wallet sends us about not supporting",
-};
-
-const SEND_CALLS_OPTIONS: Omit<SendCallsOptions, "wallet"> = {
-  calls: [
-    {
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-      data: "0xabcdef",
-      to: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
-    },
-    {
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-      to: "0xa922b54716264130634d6ff183747a8ead91a40b",
-      value: 123n,
-    },
-  ],
-};
 
 const mocks = vi.hoisted(() => ({
-  getTransactionReceipt: vi.fn(),
-  injectedRequest: vi.fn(),
+  getCallsStatus: vi.fn(),
 }));
 
-vi.mock("../injected/index.js", () => {
-  return {
-    getInjectedProvider: vi.fn().mockReturnValue({
-      request: mocks.injectedRequest,
-    }),
-  };
-});
-
-vi.mock("../../rpc/actions/eth_getTransactionReceipt.js", () => {
-  return {
-    eth_getTransactionReceipt: mocks.getTransactionReceipt.mockResolvedValue({
-      blockHash:
-        "0xf19bbafd9fd0124ec110b848e8de4ab4f62bf60c189524e54213285e7f540d4a",
-      blockNumber: 12345n,
-      gasUsed: 12345n,
-      logs: [],
-      status: "success",
-      transactionHash:
-        "0x9b7bb827c2e5e3c1a0a44dc53e573aa0b3af3bd1f9f5ed03071b100bb039eaff",
-    }),
-  };
-});
-
-vi.mock("../../transaction/actions/send-and-confirm-transaction.js", () => {
-  return {
-    sendAndConfirmTransaction: vi.fn().mockResolvedValue({
-      transactionHash:
-        "0x9b7bb827c2e5e3c1a0a44dc53e573aa0b3af3bd1f9f5ed03071b100bb039eaff",
-    }),
-  };
-});
-
-vi.mock("../../transaction/actions/send-batch-transaction.js", () => {
-  return {
-    sendBatchTransaction: vi.fn().mockResolvedValue({
-      transactionHash:
-        "0x9b7bb827c2e5e3c1a0a44dc53e573aa0b3af3bd1f9f5ed03071b100bb039eaff",
-    }),
-  };
-});
-
-describe.sequential("injected wallet", async () => {
+describe.sequential("getCallsStatus general", () => {
   const wallet: Wallet = createWallet(METAMASK);
 
   afterEach(() => {
@@ -85,6 +20,7 @@ describe.sequential("injected wallet", async () => {
 
   test("with no account should fail", async () => {
     wallet.getAccount = vi.fn().mockReturnValue(undefined);
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
     const promise = getCallsStatus({
       client: TEST_CLIENT,
@@ -93,42 +29,31 @@ describe.sequential("injected wallet", async () => {
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(
-      `[Error: Failed to get call status, no account found for wallet ${wallet.id}]`,
+      "[Error: Failed to get call status, no account found for wallet io.metamask]",
     );
   });
 
-  test("should successfully make request", async () => {
+  test("with no chain should fail", async () => {
     wallet.getAccount = vi.fn().mockReturnValue(TEST_ACCOUNT_A);
-    mocks.injectedRequest.mockResolvedValue({
-      receipts: [],
-      status: "CONFIRMED",
-    });
+    wallet.getChain = vi.fn().mockReturnValue(undefined);
 
-    const result = await getCallsStatus({
+    const promise = getCallsStatus({
       client: TEST_CLIENT,
       id: "test",
       wallet: wallet,
     });
 
-    expect(mocks.injectedRequest).toHaveBeenCalledWith({
-      method: "wallet_getCallsStatus",
-      params: ["test"],
-    });
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "atomic": false,
-        "chainId": undefined,
-        "receipts": [],
-        "status": "success",
-        "statusCode": 200,
-        "version": "2.0.0",
-      }
-    `);
+    await expect(promise).rejects.toMatchInlineSnapshot(
+      "[Error: Failed to get call status, no chain found for wallet io.metamask]",
+    );
   });
 
-  test("without support should fail", async () => {
-    mocks.injectedRequest.mockRejectedValue(RAW_UNSUPPORTED_ERROR);
-    wallet.getAccount = vi.fn().mockReturnValue(TEST_ACCOUNT_A);
+  test("without getCallsStatus support should fail", async () => {
+    wallet.getAccount = vi.fn().mockReturnValue({
+      ...TEST_ACCOUNT_A,
+      // no getCallsStatus method
+    });
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
     const promise = getCallsStatus({
       client: TEST_CLIENT,
@@ -137,103 +62,188 @@ describe.sequential("injected wallet", async () => {
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(
-      "[Error: io.metamask does not support wallet_getCallsStatus, reach out to them directly to request EIP-5792 support.]",
+      "[Error: Failed to get call status, wallet io.metamask does not support EIP-5792]",
     );
   });
-});
-
-describe.sequential("in-app wallet", async () => {
-  const sendTransaction = vi.fn();
-  const sendBatchTransaction = vi.fn();
-  let wallet: Wallet = createWallet("inApp");
 
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+  test("should delegate to account.getCallsStatus", async () => {
+    const mockResponse = {
+      status: "success" as const,
+      statusCode: 200,
+      receipts: [],
+    };
 
-  test("default", async () => {
-    wallet.getAccount = vi.fn().mockReturnValue({
+    const mockAccount = {
       ...TEST_ACCOUNT_A,
-      sendTransaction,
-    });
+      getCallsStatus: mocks.getCallsStatus.mockResolvedValue(mockResponse),
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(mockAccount);
     wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
-    const callResult = await sendCalls({
+    const result = await getCallsStatus({
+      client: TEST_CLIENT,
+      id: "test-bundle-id",
       wallet: wallet,
-      ...SEND_CALLS_OPTIONS,
     });
 
-    const result = await getCallsStatus(callResult);
-
-    expect(result.status).toEqual("success");
-    expect(result.receipts?.length).toEqual(2);
+    expect(result).toEqual(mockResponse);
+    expect(mocks.getCallsStatus).toHaveBeenCalledWith({
+      id: "test-bundle-id",
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
   });
+});
 
-  test("with smart account", async () => {
-    wallet = createWallet("inApp", {
-      smartAccount: { chain: ANVIL_CHAIN, sponsorGas: true },
-    });
-    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-    wallet.getAccount = vi.fn().mockReturnValue({
+describe.sequential("injected wallet account.getCallsStatus", () => {
+  // These tests verify the behavior of the getCallsStatus method on injected wallet accounts
+  // The actual implementation would be in packages/thirdweb/src/wallets/injected/index.ts
+
+  test("should handle successful getCallsStatus", async () => {
+    const mockProvider = {
+      request: vi.fn().mockResolvedValue({
+        receipts: [],
+        status: "CONFIRMED",
+      }),
+    };
+
+    // Mock what an injected account with getCallsStatus would look like
+    const injectedAccount = {
       ...TEST_ACCOUNT_A,
-      sendBatchTransaction,
-    });
+      getCallsStatus: async (options: any) => {
+        // This mimics the implementation in injected/index.ts
+        const response = await mockProvider.request({
+          method: "wallet_getCallsStatus",
+          params: [options.id],
+        });
+        return {
+          ...response,
+          status: "success" as const,
+          statusCode: 200,
+        };
+      },
+    };
+
+    const wallet: Wallet = createWallet(METAMASK);
+    wallet.getAccount = vi.fn().mockReturnValue(injectedAccount);
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
-    const callResult = await sendCalls({
+    const result = await getCallsStatus({
+      client: TEST_CLIENT,
+      id: "test",
       wallet: wallet,
-      ...SEND_CALLS_OPTIONS,
     });
 
-    const result = await getCallsStatus(callResult);
-
     expect(result.status).toEqual("success");
-    expect(result.receipts?.length).toEqual(1);
+    expect(result.statusCode).toEqual(200);
+    expect(mockProvider.request).toHaveBeenCalledWith({
+      method: "wallet_getCallsStatus",
+      params: ["test"],
+    });
   });
 
-  test("with pending transaction", async () => {
-    mocks.getTransactionReceipt.mockRejectedValue(null);
+  test("should handle provider errors", async () => {
+    const mockProvider = {
+      request: vi.fn().mockRejectedValue({
+        code: -32601,
+        message: "some nonsense the wallet sends us about not supporting",
+      }),
+    };
 
-    wallet = createWallet("inApp");
-    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-    wallet.getAccount = vi.fn().mockReturnValue({
+    const injectedAccount = {
       ...TEST_ACCOUNT_A,
-      sendTransaction,
-    });
+      getCallsStatus: async (options: any) => {
+        try {
+          return await mockProvider.request({
+            method: "wallet_getCallsStatus",
+            params: [options.id],
+          });
+        } catch (error) {
+          throw new Error(
+            `io.metamask does not support wallet_getCallsStatus, reach out to them directly to request EIP-5792 support.`,
+          );
+        }
+      },
+    };
+
+    const wallet: Wallet = createWallet(METAMASK);
+    wallet.getAccount = vi.fn().mockReturnValue(injectedAccount);
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
-    const callResult = await sendCalls({
+    const promise = getCallsStatus({
+      client: TEST_CLIENT,
+      id: "test",
       wallet: wallet,
-      ...SEND_CALLS_OPTIONS,
     });
 
-    const result = await getCallsStatus(callResult);
+    await expect(promise).rejects.toMatchInlineSnapshot(
+      "[Error: io.metamask does not support wallet_getCallsStatus, reach out to them directly to request EIP-5792 support.]",
+    );
+  });
+});
 
-    expect(result.status).toEqual("pending");
-    expect(result.receipts?.length).toEqual(0);
+describe.sequential("in-app wallet", () => {
+  const wallet: Wallet = createWallet("inApp");
+
+  afterEach(() => {
+    vi.clearAllMocks();
   });
 
-  test("unknown bundle id should fail", async () => {
-    const promise = getCallsStatus({
+  test("should delegate to in-app wallet getCallsStatus implementation", async () => {
+    const mockResponse = {
+      status: "success" as const,
+      statusCode: 200,
+      receipts: [
+        {
+          blockNumber: 12345n,
+          gasUsed: 21000n,
+          status: "success" as const,
+          transactionHash:
+            "0x9b7bb827c2e5e3c1a0a44dc53e573aa0b3af3bd1f9f5ed03071b100bb039eaff",
+        },
+      ],
+    };
+
+    const inAppAccount = {
+      ...TEST_ACCOUNT_A,
+      getCallsStatus: async (options: any) => {
+        // This would be the actual in-app wallet implementation
+        return mockResponse;
+      },
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(inAppAccount);
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
+
+    const result = await getCallsStatus({
       client: TEST_CLIENT,
-      id: "unknown",
+      id: "test-bundle-id",
       wallet: wallet,
     });
 
-    await expect(promise).rejects.toMatchInlineSnapshot(
-      "[Error: Failed to get calls status, unknown bundle id]",
-    );
+    expect(result).toEqual(mockResponse);
   });
 
-  test("without chain should fail", async () => {
-    wallet.getChain = vi.fn().mockReturnValue(undefined);
+  test("should handle unknown bundle id error", async () => {
+    const inAppAccount = {
+      ...TEST_ACCOUNT_A,
+      getCallsStatus: async (options: any) => {
+        throw new Error("Failed to get calls status, unknown bundle id");
+      },
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(inAppAccount);
+    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
 
     const promise = getCallsStatus({
       client: TEST_CLIENT,
-      id: "test",
+      id: "unknown",
       wallet: wallet,
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(
-      "[Error: Failed to get calls status, no active chain found]",
+      "[Error: Failed to get calls status, unknown bundle id]",
     );
   });
 });