thirdweb 5.105.20 → 5.105.22

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]",
     );
   });
 });

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,
+  };
+}