thirdweb 5.105.21 → 5.105.23

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

@@ -1,12 +1,6 @@
 import type { ThirdwebClient } from "../../client/client.js";
 import { hexToBigInt, hexToNumber } from "../../utils/encoding/hex.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
-import { isInAppWallet } from "../in-app/core/wallet/index.js";
-import { getInjectedProvider } from "../injected/index.js";
-import type { Ethereum } from "../interfaces/ethereum.js";
 import type { Wallet } from "../interfaces/wallet.js";
-import { isSmartWallet } from "../smart/index.js";
-import { isWalletConnect } from "../wallet-connect/controller.js";
 import type {
   GetCallsStatusRawResponse,
   GetCallsStatusResponse,
@@ -59,81 +53,58 @@ export async function getCallsStatus({
     );
   }
 
-  // These conveniently operate the same
-  if (isSmartWallet(wallet) || isInAppWallet(wallet)) {
-    const { inAppWalletGetCallsStatus } = await import(
-      "../in-app/core/eip5972/in-app-wallet-calls.js"
+  const chain = wallet.getChain();
+  if (!chain) {
+    throw new Error(
+      `Failed to get call status, no chain found for wallet ${wallet.id}`,
     );
-    return inAppWalletGetCallsStatus({ client, id, wallet });
-  }
-
-  if (isWalletConnect(wallet)) {
-    throw new Error("getCallsStatus is not yet supported for Wallet Connect");
   }
 
-  let provider: Ethereum;
-  if (isCoinbaseSDKWallet(wallet)) {
-    const { getCoinbaseWebProvider } = await import(
-      "../coinbase/coinbase-web.js"
-    );
-    const config = wallet.getConfig();
-    provider = (await getCoinbaseWebProvider(config)) as Ethereum;
-  } else {
-    provider = getInjectedProvider(wallet.id);
+  if (account.getCallsStatus) {
+    return account.getCallsStatus({ id, chain, client });
   }
 
-  try {
-    const {
-      atomic = false,
-      chainId,
-      receipts,
-      version = "2.0.0",
-      ...response
-    } = (await provider.request({
-      method: "wallet_getCallsStatus",
-      params: [id],
-    })) as GetCallsStatusRawResponse;
-    const [status, statusCode] = (() => {
-      const statusCode = response.status;
-      if (statusCode >= 100 && statusCode < 200)
-        return ["pending", statusCode] as const;
-      if (statusCode >= 200 && statusCode < 300)
-        return ["success", statusCode] as const;
-      if (statusCode >= 300 && statusCode < 700)
-        return ["failure", statusCode] as const;
-      // @ts-expect-error: for backwards compatibility
-      if (statusCode === "CONFIRMED") return ["success", 200] as const;
-      // @ts-expect-error: for backwards compatibility
-      if (statusCode === "PENDING") return ["pending", 100] as const;
-      return [undefined, statusCode];
-    })();
-    return {
-      ...response,
-      atomic,
-      // @ts-expect-error: for backwards compatibility
-      chainId: chainId ? hexToNumber(chainId) : undefined,
-      receipts:
-        receipts?.map((receipt) => ({
-          ...receipt,
-          blockNumber: hexToBigInt(receipt.blockNumber),
-          gasUsed: hexToBigInt(receipt.gasUsed),
-          status: receiptStatuses[receipt.status as "0x0" | "0x1"],
-        })) ?? [],
-      status,
-      statusCode,
-      version,
-    };
-  } catch (error) {
-    if (/unsupport|not support/i.test((error as Error).message)) {
-      throw new Error(
-        `${wallet.id} does not support wallet_getCallsStatus, reach out to them directly to request EIP-5792 support.`,
-      );
-    }
-    throw error;
-  }
+  throw new Error(
+    `Failed to get call status, wallet ${wallet.id} does not support EIP-5792`,
+  );
 }
 
 const receiptStatuses = {
   "0x0": "reverted",
   "0x1": "success",
 } as const;
+
+export function toGetCallsStatusResponse(
+  response: GetCallsStatusRawResponse,
+): GetCallsStatusResponse {
+  const [status, statusCode] = (() => {
+    const statusCode = response.status;
+    if (statusCode >= 100 && statusCode < 200)
+      return ["pending", statusCode] as const;
+    if (statusCode >= 200 && statusCode < 300)
+      return ["success", statusCode] as const;
+    if (statusCode >= 300 && statusCode < 700)
+      return ["failure", statusCode] as const;
+    // @ts-expect-error: for backwards compatibility
+    if (statusCode === "CONFIRMED") return ["success", 200] as const;
+    // @ts-expect-error: for backwards compatibility
+    if (statusCode === "PENDING") return ["pending", 100] as const;
+    return [undefined, statusCode];
+  })();
+  return {
+    ...response,
+    atomic: response.atomic,
+    // @ts-expect-error: for backwards compatibility
+    chainId: response.chainId ? hexToNumber(response.chainId) : undefined,
+    receipts:
+      response.receipts?.map((receipt) => ({
+        ...receipt,
+        blockNumber: hexToBigInt(receipt.blockNumber),
+        gasUsed: hexToBigInt(receipt.gasUsed),
+        status: receiptStatuses[receipt.status as "0x0" | "0x1"],
+      })) ?? [],
+    status,
+    statusCode,
+    version: response.version,
+  };
+}

package/src/wallets/eip5792/get-capabilities.test.ts

@@ -1,261 +1,242 @@
-import { afterEach, beforeAll, describe, expect, it, test, vi } from "vitest";
-import {
-  ANVIL_CHAIN,
-  FORKED_ETHEREUM_CHAIN,
-} from "../../../test/src/chains.js";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
 import { METAMASK } from "../constants.js";
 import { createWallet } from "../create-wallet.js";
 import type { Wallet } from "../interfaces/wallet.js";
-import { getCapabilities } from "./get-capabilities.js";
-
-const SUPPORTED_RESPONSE = {
-  1: {
-    paymasterService: {
-      supported: true,
-    },
-    sessionKeys: {
-      supported: true,
-    },
-  },
-};
-
-const RAW_UNSUPPORTED_ERROR = {
-  code: -32601,
-  message: "some nonsense the wallet sends us about not supporting",
-};
-
-const UNSUPPORTED_RESPONSE_STRING = "does not support wallet_getCapabilities";
+import {
+  type GetCapabilitiesOptions,
+  getCapabilities,
+} from "./get-capabilities.js";
 
 const mocks = vi.hoisted(() => ({
-  injectedRequest: vi.fn(),
+  getCapabilities: vi.fn(),
 }));
 
-vi.mock("../injected/index.js", () => {
-  return {
-    getInjectedProvider: vi.fn().mockReturnValue({
-      request: mocks.injectedRequest,
-    }),
-  };
-});
-
-describe.sequential("injected wallet", async () => {
+describe.sequential("getCapabilities general", () => {
   const wallet: Wallet = createWallet(METAMASK);
-  describe.sequential("supported", () => {
-    beforeAll(() => {
-      mocks.injectedRequest.mockResolvedValue(SUPPORTED_RESPONSE);
-    });
-
-    afterEach(() => {
-      mocks.injectedRequest.mockClear();
-    });
 
-    test("without account should return no capabilities", async () => {
-      wallet.getAccount = vi.fn().mockReturnValue(undefined);
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
 
-      const capabilities = await getCapabilities({
-        wallet,
-      });
+  test("without account should return message", async () => {
+    wallet.getAccount = vi.fn().mockReturnValue(undefined);
 
-      expect(mocks.injectedRequest).not.toHaveBeenCalled();
-      expect(capabilities).toEqual({
-        message:
-          "Can't get capabilities, no account connected for wallet: io.metamask",
-      });
+    const capabilities = await getCapabilities({
+      wallet,
     });
 
-    test("with account should return capabilities", async () => {
-      wallet.getAccount = vi.fn().mockReturnValue(TEST_ACCOUNT_A);
-
-      const capabilities = await getCapabilities({
-        wallet,
-      });
-
-      expect(mocks.injectedRequest).toHaveBeenCalledWith({
-        method: "wallet_getCapabilities",
-        params: [TEST_ACCOUNT_A.address],
-      });
-      expect(capabilities).toEqual(SUPPORTED_RESPONSE);
+    expect(capabilities).toEqual({
+      message:
+        "Can't get capabilities, no account connected for wallet: io.metamask",
     });
   });
 
-  describe("unsupported", () => {
-    beforeAll(() => {
-      mocks.injectedRequest.mockRejectedValue(RAW_UNSUPPORTED_ERROR);
+  test("without getCapabilities support should fail", async () => {
+    wallet.getAccount = vi.fn().mockReturnValue({
+      ...TEST_ACCOUNT_A,
+      // no getCapabilities method
     });
 
-    afterEach(() => {
-      mocks.injectedRequest.mockClear();
+    const promise = getCapabilities({
+      wallet,
     });
 
-    it("should return clean unsupported response", async () => {
-      wallet.getAccount = vi.fn().mockReturnValue(TEST_ACCOUNT_A);
-      wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-      const capabilities = await getCapabilities({
-        wallet,
-      });
-
-      expect(mocks.injectedRequest).toHaveBeenCalledWith({
-        method: "wallet_getCapabilities",
-        params: [TEST_ACCOUNT_A.address],
-      });
-      if ("message" in capabilities) {
-        expect(capabilities.message).toContain(UNSUPPORTED_RESPONSE_STRING);
-      } else {
-        throw new Error("capabilities does not contain message");
-      }
-    });
+    await expect(promise).rejects.toMatchInlineSnapshot(
+      "[Error: Failed to get capabilities, wallet io.metamask does not support EIP-5792]",
+    );
   });
-});
 
-describe.sequential("in-app wallet", async () => {
-  let wallet: Wallet = createWallet("inApp");
+  test("should delegate to account.getCapabilities", async () => {
+    const mockResponse = {
+      [ANVIL_CHAIN.id]: {
+        paymasterService: {
+          supported: true,
+        },
+        sessionKeys: {
+          supported: true,
+        },
+      },
+    };
 
-  test("should return no support", async () => {
-    wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-    wallet.getAccount = vi.fn().mockReturnValue(TEST_ACCOUNT_A);
+    const mockAccount = {
+      ...TEST_ACCOUNT_A,
+      getCapabilities: mocks.getCapabilities.mockResolvedValue(mockResponse),
+    };
 
-    const capabilities = await getCapabilities({
+    wallet.getAccount = vi.fn().mockReturnValue(mockAccount);
+
+    const result = await getCapabilities({
       wallet,
     });
 
-    expect(capabilities).toEqual({
-      [ANVIL_CHAIN.id]: {
-        atomic: {
-          status: "unsupported",
-        },
-        paymasterService: {
-          supported: false,
-        },
-      },
+    expect(result).toEqual(mockResponse);
+    expect(mocks.getCapabilities).toHaveBeenCalledWith({
+      chainId: undefined,
     });
   });
 
-  test("with no account should return no capabilities", async () => {
-    wallet.getAccount = vi.fn().mockReturnValue(undefined);
+  test("should delegate to account.getCapabilities with chainId", async () => {
+    const mockResponse = {
+      paymasterService: {
+        supported: true,
+      },
+      sessionKeys: {
+        supported: true,
+      },
+    };
 
-    const capabilities = await getCapabilities({
+    const mockAccount = {
+      ...TEST_ACCOUNT_A,
+      getCapabilities: mocks.getCapabilities.mockResolvedValue(mockResponse),
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(mockAccount);
+
+    const result = await getCapabilities({
       wallet,
+      chainId: ANVIL_CHAIN.id,
     });
 
-    expect(capabilities).toEqual({
-      message: "Can't get capabilities, no account connected for wallet: inApp",
+    expect(result).toEqual(mockResponse);
+    expect(mocks.getCapabilities).toHaveBeenCalledWith({
+      chainId: ANVIL_CHAIN.id,
     });
   });
+});
 
-  describe.sequential("with smart account", async () => {
-    test("with sponsorGas should support paymasterService and atomicBatch", async () => {
-      wallet = createWallet("inApp", {
-        smartAccount: {
-          chain: ANVIL_CHAIN,
-          sponsorGas: true,
-        },
-      });
-
-      wallet.getAccount = vi.fn().mockReturnValue({
-        ...TEST_ACCOUNT_A,
-        sendBatchTransaction: vi.fn(),
-      });
-      wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-
-      const capabilities = await getCapabilities({
-        wallet,
-      });
+describe.sequential("injected wallet account.getCapabilities", () => {
+  // These tests verify the behavior of the getCapabilities method on injected wallet accounts
+  // The actual implementation would be in packages/thirdweb/src/wallets/injected/index.ts
 
-      expect(capabilities).toEqual({
+  test("should handle successful getCapabilities", async () => {
+    const mockProvider = {
+      request: vi.fn().mockResolvedValue({
         [ANVIL_CHAIN.id]: {
-          atomic: {
-            status: "supported",
-          },
           paymasterService: {
             supported: true,
           },
+          sessionKeys: {
+            supported: true,
+          },
         },
-      });
+      }),
+    };
+
+    // Mock what an injected account with getCapabilities would look like
+    const injectedAccount = {
+      ...TEST_ACCOUNT_A,
+      getCapabilities: async (_options: any) => {
+        // This mimics the implementation in injected/index.ts
+        const response = await mockProvider.request({
+          method: "wallet_getCapabilities",
+          params: [injectedAccount.address],
+        });
+        return response;
+      },
+    };
+
+    const wallet: Wallet = createWallet(METAMASK);
+    wallet.getAccount = vi.fn().mockReturnValue(injectedAccount);
+
+    const result = await getCapabilities({
+      wallet,
     });
 
-    test("without sponsorGas should support atomicBatch", async () => {
-      wallet = createWallet("inApp", {
-        smartAccount: {
-          chain: ANVIL_CHAIN,
-          sponsorGas: false,
+    expect(result).toEqual({
+      [ANVIL_CHAIN.id]: {
+        paymasterService: {
+          supported: true,
         },
-      });
-      wallet.getAccount = vi.fn().mockReturnValue({
-        ...TEST_ACCOUNT_A,
-        sendBatchTransaction: vi.fn(),
-      });
-      wallet.getChain = vi.fn().mockReturnValue(ANVIL_CHAIN);
-
-      const capabilities = await getCapabilities({
-        wallet,
-      });
-
-      expect(capabilities).toEqual({
-        [ANVIL_CHAIN.id]: {
-          atomic: {
-            status: "supported",
-          },
-          paymasterService: {
-            supported: false,
-          },
+        sessionKeys: {
+          supported: true,
         },
-      });
+      },
+    });
+    expect(mockProvider.request).toHaveBeenCalledWith({
+      method: "wallet_getCapabilities",
+      params: [TEST_ACCOUNT_A.address],
     });
   });
-});
 
-describe.sequential("smart wallet", async () => {
-  let wallet: Wallet = createWallet("smart", {
-    chain: FORKED_ETHEREUM_CHAIN,
-    sponsorGas: true,
-  });
-  const smartAccount = {
-    ...TEST_ACCOUNT_A,
-    sendBatchTransaction: vi.fn(),
-  };
+  test("should handle provider errors", async () => {
+    const mockProvider = {
+      request: vi.fn().mockRejectedValue({
+        code: -32601,
+        message: "some nonsense the wallet sends us about not supporting",
+      }),
+    };
+
+    const injectedAccount = {
+      ...TEST_ACCOUNT_A,
+      getCapabilities: async (_options: any) => {
+        try {
+          return await mockProvider.request({
+            method: "wallet_getCapabilities",
+            params: [injectedAccount.address],
+          });
+        } catch {
+          return {
+            message: `io.metamask does not support wallet_getCapabilities, reach out to them directly to request EIP-5792 support.`,
+          };
+        }
+      },
+    };
 
-  test("with no chain should return no capabilities", async () => {
-    wallet.getAccount = vi.fn().mockReturnValue(smartAccount);
-    wallet.getChain = vi.fn().mockReturnValue(undefined);
+    const wallet: Wallet = createWallet(METAMASK);
+    wallet.getAccount = vi.fn().mockReturnValue(injectedAccount);
 
-    const capabilities = await getCapabilities({
+    const result = await getCapabilities({
       wallet,
     });
 
-    expect(capabilities).toEqual({
+    expect(result).toEqual({
       message:
-        "Can't get capabilities, no active chain found for wallet: smart",
+        "io.metamask does not support wallet_getCapabilities, reach out to them directly to request EIP-5792 support.",
     });
   });
+});
 
-  test("with no account should return no capabilities", async () => {
-    wallet.getAccount = vi.fn().mockReturnValue(undefined);
-    wallet.getChain = vi.fn().mockReturnValue(FORKED_ETHEREUM_CHAIN);
-
-    const capabilities = await getCapabilities({
-      wallet,
-    });
+describe.sequential("in-app wallet", () => {
+  const wallet: Wallet = createWallet("inApp");
 
-    expect(capabilities).toEqual({
-      message: "Can't get capabilities, no account connected for wallet: smart",
-    });
+  afterEach(() => {
+    vi.clearAllMocks();
   });
 
-  test("with sponsorGas should support paymasterService and atomicBatch", async () => {
-    wallet = createWallet("smart", {
-      chain: ANVIL_CHAIN,
-      sponsorGas: true,
-    });
-    wallet.getAccount = vi.fn().mockReturnValue(smartAccount);
-    wallet.getChain = vi.fn().mockReturnValue(FORKED_ETHEREUM_CHAIN);
+  test("should delegate to in-app wallet getCapabilities implementation", async () => {
+    const mockResponse = {
+      [ANVIL_CHAIN.id]: {
+        atomic: {
+          status: "unsupported",
+        },
+        paymasterService: {
+          supported: false,
+        },
+      },
+    };
 
-    const capabilities = await getCapabilities({
+    const inAppAccount = {
+      ...TEST_ACCOUNT_A,
+      getCapabilities: async (_options: GetCapabilitiesOptions) => {
+        // This would be the actual in-app wallet implementation
+        return mockResponse;
+      },
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(inAppAccount);
+
+    const result = await getCapabilities({
       wallet,
     });
 
-    expect(capabilities).toEqual({
-      [FORKED_ETHEREUM_CHAIN.id]: {
+    expect(result).toEqual(mockResponse);
+  });
+
+  test("should handle smart account capabilities", async () => {
+    const mockResponse = {
+      [ANVIL_CHAIN.id]: {
         atomic: {
           status: "supported",
         },
@@ -263,32 +244,62 @@ describe.sequential("smart wallet", async () => {
           supported: true,
         },
       },
-    });
-  });
+    };
+
+    const smartAccount = {
+      ...TEST_ACCOUNT_A,
+      sendBatchTransaction: vi.fn(), // indicates it's a smart account
+      getCapabilities: async (_options: GetCapabilitiesOptions) => {
+        return mockResponse;
+      },
+    };
 
-  test("without sponsorGas should return atomicBatch", async () => {
-    wallet = createWallet("smart", {
-      chain: FORKED_ETHEREUM_CHAIN,
-      sponsorGas: false,
-    });
-    wallet.getChain = vi.fn().mockReturnValue(FORKED_ETHEREUM_CHAIN);
     wallet.getAccount = vi.fn().mockReturnValue(smartAccount);
 
-    const capabilities = await getCapabilities({
+    const result = await getCapabilities({
       wallet,
     });
 
-    expect(capabilities).toEqual({
-      [FORKED_ETHEREUM_CHAIN.id]: {
+    expect(result).toEqual(mockResponse);
+  });
+});
+
+describe.sequential("smart wallet", () => {
+  const wallet: Wallet = createWallet("smart", {
+    chain: ANVIL_CHAIN,
+    sponsorGas: true,
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should delegate to smart wallet getCapabilities implementation", async () => {
+    const mockResponse = {
+      [ANVIL_CHAIN.id]: {
         atomic: {
           status: "supported",
         },
         paymasterService: {
-          supported: false,
+          supported: true,
         },
       },
+    };
+
+    const smartAccount = {
+      ...TEST_ACCOUNT_A,
+      sendBatchTransaction: vi.fn(),
+      getCapabilities: async (_options: GetCapabilitiesOptions) => {
+        return mockResponse;
+      },
+    };
+
+    wallet.getAccount = vi.fn().mockReturnValue(smartAccount);
+
+    const result = await getCapabilities({
+      wallet,
     });
+
+    expect(result).toEqual(mockResponse);
   });
 });
-
-// TODO: Coinbase SDK Tests