thirdweb 5.98.2 → 5.99.0

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

@@ -1,8 +1,12 @@
 import { getAddress } from "../../utils/address.js";
 import type { Prettify } from "../../utils/type-utils.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
+import {
+  type CoinbaseWalletCreationOptions,
+  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 { isWalletConnect } from "../wallet-connect/controller.js";
 import type { WalletId } from "../wallet-types.js";
@@ -10,6 +14,7 @@ import type { WalletCapabilities, WalletCapabilitiesRecord } from "./types.js";
 
 export type GetCapabilitiesOptions<ID extends WalletId = WalletId> = {
   wallet: Wallet<ID>;
+  chainId?: number;
 };
 
 export type GetCapabilitiesResult = Prettify<
@@ -38,6 +43,7 @@ export type GetCapabilitiesResult = Prettify<
  */
 export async function getCapabilities<const ID extends WalletId = WalletId>({
   wallet,
+  chainId,
 }: GetCapabilitiesOptions<ID>): Promise<GetCapabilitiesResult> {
   const account = wallet.getAccount();
   if (!account) {
@@ -60,13 +66,6 @@ export async function getCapabilities<const ID extends WalletId = WalletId>({
     return inAppWalletGetCapabilities({ wallet });
   }
 
-  if (isCoinbaseSDKWallet(wallet)) {
-    const { coinbaseSDKWalletGetCapabilities } = await import(
-      "../coinbase/coinbase-web.js"
-    );
-    return coinbaseSDKWalletGetCapabilities({ wallet });
-  }
-
   // TODO: Add Wallet Connect support
   if (isWalletConnect(wallet)) {
     return {
@@ -74,14 +73,37 @@ export async function getCapabilities<const ID extends WalletId = WalletId>({
     };
   }
 
-  // Default to injected wallet
-  const provider = getInjectedProvider(wallet.id);
+  let provider: Ethereum;
+  if (isCoinbaseSDKWallet(wallet)) {
+    const { getCoinbaseWebProvider } = await import(
+      "../coinbase/coinbase-web.js"
+    );
+    const config = wallet.getConfig() as CoinbaseWalletCreationOptions;
+    provider = (await getCoinbaseWebProvider(config)) as Ethereum;
+  } else {
+    provider = getInjectedProvider(wallet.id);
+  }
 
   try {
-    return await provider.request({
+    const result = await provider.request({
       method: "wallet_getCapabilities",
       params: [getAddress(account.address)],
     });
+    const capabilities = {} as WalletCapabilitiesRecord<
+      WalletCapabilities,
+      number
+    >;
+    for (const [chainId, capabilities_] of Object.entries(result)) {
+      capabilities[Number(chainId)] = {};
+      const capabilitiesCopy = {} as WalletCapabilities;
+      for (const [key, value] of Object.entries(capabilities_)) {
+        capabilitiesCopy[key] = value;
+      }
+      capabilities[Number(chainId)] = capabilitiesCopy;
+    }
+    return (
+      typeof chainId === "number" ? capabilities[chainId] : capabilities
+    ) as never;
   } catch (error: unknown) {
     if (/unsupport|not support|not available/i.test((error as Error).message)) {
       return {

package/src/wallets/eip5792/send-and-confirm-calls.ts

@@ -0,0 +1,48 @@
+import type { WalletId } from "../wallet-types.js";
+import { type SendCallsOptions, sendCalls } from "./send-calls.js";
+import type { GetCallsStatusResponse } from "./types.js";
+import { waitForCallsReceipt } from "./wait-for-calls-receipt.js";
+
+/**
+ * Send and confirm calls in a single transaction.
+ *
+ * This is a convenience function that sends the calls with `sendCalls` and then waits for the receipts with `waitForCallsReceipt`.
+ *
+ * @param options - The options for sending and confirming calls.
+ * @returns The receipts of the calls.
+ * @example
+ * ```ts
+ * const call1 = approve({
+ *   contract: USDT_CONTRACT,
+ *   amount: 100,
+ *   spender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+ * });
+ * const call2 = transfer({
+ *   contract: USDT_CONTRACT,
+ *   to: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+ *   amount: 100,
+ * });
+ * const result = await sendAndConfirmCalls({
+ *   calls: [call1, call2],
+ *   wallet: wallet,
+ * });
+ * console.log("Transaction receipts:", result.receipts);
+ * ```
+ * @extension EIP5792
+ * @beta
+ */
+export async function sendAndConfirmCalls<const ID extends WalletId>(
+  options: SendCallsOptions<ID> & {
+    /**
+     * The maximum number of blocks to wait for the calls to be confirmed.
+     * @defaultValue 100
+     */
+    maxBlocksWaitTime?: number;
+  },
+): Promise<GetCallsStatusResponse> {
+  const sendCallsResult = await sendCalls(options);
+  return waitForCallsReceipt({
+    ...sendCallsResult,
+    maxBlocksWaitTime: options.maxBlocksWaitTime,
+  });
+}

package/src/wallets/eip5792/send-calls.test.ts

@@ -111,7 +111,7 @@ describe.sequential("injected wallet", () => {
 
     const result = await sendCalls({ wallet, ...SEND_CALLS_OPTIONS });
 
-    expect(result).toEqual("0x123456");
+    expect(result.id).toEqual("0x123456");
     expect(mocks.injectedRequest).toHaveBeenCalledWith({
       method: "wallet_sendCalls",
       params: [
@@ -132,7 +132,7 @@ describe.sequential("injected wallet", () => {
           capabilities: undefined,
           chainId: numberToHex(ANVIL_CHAIN.id),
           from: TEST_ACCOUNT_A.address,
-          version: "1.0",
+          version: "2.0.0",
         },
       ],
     });
@@ -159,7 +159,7 @@ describe.sequential("injected wallet", () => {
       calls: [preparedTx, preparedTx2],
     });
 
-    expect(result).toEqual("0x123456");
+    expect(result.id).toEqual("0x123456");
     expect(mocks.injectedRequest).toHaveBeenCalledWith({
       method: "wallet_sendCalls",
       params: [
@@ -180,7 +180,7 @@ describe.sequential("injected wallet", () => {
           capabilities: undefined,
           chainId: numberToHex(ANVIL_CHAIN.id),
           from: TEST_ACCOUNT_A.address,
-          version: "1.0",
+          version: "2.0.0",
         },
       ],
     });
@@ -194,7 +194,7 @@ describe.sequential("injected wallet", () => {
       ...SEND_CALLS_OPTIONS,
     });
 
-    expect(result).toEqual("0x123456");
+    expect(result.id).toEqual("0x123456");
     expect(mocks.injectedRequest).toHaveBeenCalledWith({
       method: "wallet_sendCalls",
       params: [
@@ -215,7 +215,7 @@ describe.sequential("injected wallet", () => {
           capabilities: undefined,
           chainId: numberToHex(sepolia.id),
           from: TEST_ACCOUNT_A.address,
-          version: "1.0",
+          version: "2.0.0",
         },
       ],
     });
@@ -231,7 +231,7 @@ describe.sequential("injected wallet", () => {
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(
-      "[Error: io.metamask does not support wallet_sendCalls, reach out to them directly to request EIP-5792 support.]",
+      `[Error: io.metamask errored calling wallet_sendCalls, with error: {"code":-32601,"message":"some nonsense the wallet sends us about not supporting"}]`,
     );
   });
 });

package/src/wallets/eip5792/send-calls.ts

@@ -6,14 +6,19 @@ import { encode } from "../../transaction/actions/encode.js";
 import type { PreparedTransaction } from "../../transaction/prepare-transaction.js";
 import { type Address, getAddress } from "../../utils/address.js";
 import { type Hex, numberToHex } from "../../utils/encoding/hex.js";
+import { stringify } from "../../utils/json.js";
 import {
   type PromisedObject,
   resolvePromisedValue,
 } from "../../utils/promise/resolve-promised-value.js";
-import type { OneOf } from "../../utils/type-utils.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
+import type { OneOf, Prettify } from "../../utils/type-utils.js";
+import {
+  type CoinbaseWalletCreationOptions,
+  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";
@@ -44,16 +49,21 @@ export type SendCallsOptions<
   ID extends WalletId = WalletId,
   abi extends Abi = [],
   abiFunction extends AbiFunction = AbiFunction,
-> = {
+> = Prettify<{
   wallet: Wallet<ID>;
   calls: PreparedSendCall<abi, abiFunction>[];
   capabilities?: WalletSendCallsParameters[number]["capabilities"];
   version?: WalletSendCallsParameters[number]["version"];
   chain?: Chain;
   atomicRequired?: boolean;
-};
+}>;
 
-export type SendCallsResult = WalletSendCallsId;
+export type SendCallsResult = Prettify<{
+  id: WalletSendCallsId;
+  client: ThirdwebClient;
+  chain: Chain;
+  wallet: Wallet;
+}>;
 
 /**
  * Send [EIP-5792](https://eips.ethereum.org/EIPS/eip-5792) calls to a wallet.
@@ -81,6 +91,7 @@ export type SendCallsResult = WalletSendCallsId;
  *
  * const client = createThirdwebClient({ clientId: ... });
  * const wallet = createWallet("com.coinbase.wallet");
+ * await wallet.connect({ client });
  *
  * const sendTx1 = approve({
       contract: USDT_CONTRACT,
@@ -110,8 +121,9 @@ export type SendCallsResult = WalletSendCallsId;
  *     }
  *   }
  * });
- *  We recommend proxying any paymaster calls via an API route you setup and control.
  * ```
+ * We recommend proxying any paymaster calls via an API route you setup and control.
+ * 
  * @extension EIP5792
  */
 export async function sendCalls<const ID extends WalletId>(
@@ -121,7 +133,7 @@ export async function sendCalls<const ID extends WalletId>(
     wallet,
     calls,
     capabilities,
-    version = "1.0",
+    version = "2.0.0",
     chain = wallet.getChain(),
   } = options;
 
@@ -138,12 +150,19 @@ export async function sendCalls<const ID extends WalletId>(
     );
   }
 
+  const firstCall = options.calls[0];
+  if (!firstCall) {
+    throw new Error("No calls to send");
+  }
+  const client = firstCall.client;
+
   // These conveniently operate the same
   if (isSmartWallet(wallet) || isInAppWallet(wallet)) {
     const { inAppWalletSendCalls } = await import(
       "../in-app/core/eip5972/in-app-wallet-calls.js"
     );
-    return inAppWalletSendCalls({ account, calls });
+    const id = await inAppWalletSendCalls({ account, calls });
+    return { id, client, chain, wallet };
   }
 
   const preparedCalls: EIP5792Call[] = await Promise.all(
@@ -182,31 +201,34 @@ export async function sendCalls<const ID extends WalletId>(
     },
   ];
 
+  if (isWalletConnect(wallet)) {
+    throw new Error("sendCalls is not yet supported for Wallet Connect");
+  }
+
+  let provider: Ethereum;
   if (isCoinbaseSDKWallet(wallet)) {
-    const { coinbaseSDKWalletSendCalls } = await import(
+    const { getCoinbaseWebProvider } = await import(
       "../coinbase/coinbase-web.js"
     );
-    return coinbaseSDKWalletSendCalls({
-      wallet,
-      params: injectedWalletCallParams,
-    });
-  }
-
-  if (isWalletConnect(wallet)) {
-    throw new Error("sendCalls is not yet supported for Wallet Connect");
+    const config = wallet.getConfig() as CoinbaseWalletCreationOptions;
+    provider = (await getCoinbaseWebProvider(config)) as Ethereum;
+  } else {
+    provider = getInjectedProvider(wallet.id);
   }
 
-  // Default to injected wallet
-  const provider = getInjectedProvider(wallet.id);
   try {
-    return await provider.request({
+    const callId = await provider.request({
       method: "wallet_sendCalls",
       params: injectedWalletCallParams as ViemWalletSendCallsParameters, // The viem type definition is slightly different
     });
+    if (typeof callId === "object" && "id" in callId) {
+      return { id: callId.id, client, chain, wallet };
+    }
+    return { id: callId, client, chain, wallet };
   } catch (error) {
     if (/unsupport|not support/i.test((error as Error).message)) {
       throw new Error(
-        `${wallet.id} does not support wallet_sendCalls, reach out to them directly to request EIP-5792 support.`,
+        `${wallet.id} errored calling wallet_sendCalls, with error: ${error instanceof Error ? error.message : stringify(error)}`,
       );
     }
     throw error;

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

@@ -26,7 +26,7 @@ describe.sequential("injected wallet", async () => {
   const wallet: Wallet<typeof METAMASK> = createWallet(METAMASK);
 
   test("should run", async () => {
-    await showCallsStatus({ wallet, bundleId: "test" });
+    await showCallsStatus({ wallet, id: "test" });
 
     expect(mocks.injectedRequest).toHaveBeenCalledWith({
       method: "wallet_showCallsStatus",
@@ -38,7 +38,7 @@ describe.sequential("injected wallet", async () => {
     mocks.injectedRequest.mockRejectedValue(RAW_UNSUPPORTED_ERROR);
     const promise = showCallsStatus({
       wallet: wallet as Wallet<InjectedSupportedWalletIds>,
-      bundleId: "test",
+      id: "test",
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(
@@ -53,7 +53,7 @@ describe.sequential("other wallets", async () => {
   test("do not support", async () => {
     const promise = showCallsStatus({
       wallet: wallet as Wallet<InjectedSupportedWalletIds>,
-      bundleId: "test",
+      id: "test",
     });
 
     await expect(promise).rejects.toMatchInlineSnapshot(

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

@@ -1,6 +1,10 @@
-import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
+import {
+  getCoinbaseWebProvider,
+  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";
@@ -8,7 +12,7 @@ import type { WalletSendCallsId } from "./types.js";
 
 type ShowCallsStatusOptions = {
   wallet: Wallet;
-  bundleId: WalletSendCallsId;
+  id: WalletSendCallsId;
 };
 
 /**
@@ -37,7 +41,7 @@ type ShowCallsStatusOptions = {
  */
 export async function showCallsStatus({
   wallet,
-  bundleId,
+  id,
 }: ShowCallsStatusOptions): Promise<void> {
   if (
     isSmartWallet(wallet) ||
@@ -49,21 +53,18 @@ export async function showCallsStatus({
     );
   }
 
+  let provider: Ethereum;
   if (isCoinbaseSDKWallet(wallet)) {
-    const { coinbaseSDKWalletShowCallsStatus } = await import(
-      "../coinbase/coinbase-web.js"
-    );
-    await coinbaseSDKWalletShowCallsStatus({ wallet, bundleId });
-    return;
+    provider = (await getCoinbaseWebProvider(wallet.getConfig())) as Ethereum;
+  } else {
+    // Default to injected wallet
+    provider = getInjectedProvider(wallet.id);
   }
 
-  // Default to injected wallet
-  const provider = getInjectedProvider(wallet.id);
-
   try {
     return await provider.request({
       method: "wallet_showCallsStatus",
-      params: [bundleId],
+      params: [id],
     });
   } catch (error: unknown) {
     if (/unsupport|not support/i.test((error as Error).message)) {

package/src/wallets/eip5792/types.ts

@@ -1,6 +1,6 @@
 import type { Address } from "../../utils/address.js";
 import type { Hex } from "../../utils/encoding/hex.js";
-import type { OneOf } from "../../utils/type-utils.js";
+import type { OneOf, Prettify } from "../../utils/type-utils.js";
 
 export type WalletCapabilities = {
   [capability: string]: unknown;
@@ -42,9 +42,48 @@ export type EIP5792Call = OneOf<
     }
 >;
 
-export type GetCallsStatusResponse = {
-  status: "PENDING" | "CONFIRMED";
-  receipts: WalletCallReceipt<bigint, "success" | "reverted">[];
+type WalletGetCallsStatusReturnType<
+  numberType = Hex,
+  bigintType = Hex,
+  receiptStatus = Hex,
+> = Prettify<{
+  atomic: boolean;
+  chainId: numberType;
+  id: string;
+  receipts?: WalletCallReceipt<bigintType, receiptStatus>[] | undefined;
+  status: number;
+  version: string;
+}>;
+
+export type GetCallsStatusResponse = Prettify<
+  Omit<
+    WalletGetCallsStatusReturnType<number, bigint, "success" | "reverted">,
+    "status"
+  > & {
+    statusCode: number;
+    status: "pending" | "success" | "failure" | undefined;
+  }
+>;
+
+export type GetCallsStatusRawResponse = {
+  version: string;
+  id: `0x${string}`;
+  chainId: `0x${string}`;
+  status: number; // See "Status Codes"
+  atomic: boolean;
+  receipts?: {
+    logs: {
+      address: `0x${string}`;
+      data: `0x${string}`;
+      topics: `0x${string}`[];
+    }[];
+    status: `0x${string}`; // Hex 1 or 0 for success or failure, respectively
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    gasUsed: `0x${string}`;
+    transactionHash: `0x${string}`;
+  }[];
+  capabilities?: Record<string, unknown>;
 };
 
 export type WalletCallReceipt<quantity = Hex, status = Hex> = {

package/src/wallets/eip5792/{wait-for-bundle.test.ts → wait-for-calls-receipt.test.ts}

@@ -3,16 +3,16 @@ import { ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
 import * as watchBlockNumberExports from "../../rpc/watchBlockNumber.js";
-import * as getCallsStatusExports from "../../wallets/eip5792/get-calls-status.js";
 import { METAMASK } from "../constants.js";
 import { createWallet } from "../create-wallet.js";
+import * as getCallsStatusExports from "./get-calls-status.js";
 import type { GetCallsStatusResponse } from "./types.js";
-import { waitForBundle } from "./wait-for-bundle.js";
+import { waitForCallsReceipt } from "./wait-for-calls-receipt.js";
 
-const MOCK_BUNDLE_ID = "0x1234567890abcdef";
+const MOCK_CALL_ID = "0x1234567890abcdef";
 
 const MOCK_SUCCESS_RECEIPT: GetCallsStatusResponse = {
-  status: "CONFIRMED",
+  status: "success",
   receipts: [
     {
       logs: [],
@@ -25,11 +25,21 @@ const MOCK_SUCCESS_RECEIPT: GetCallsStatusResponse = {
       gasUsed: 12345n,
     },
   ],
+  atomic: false,
+  chainId: 1,
+  id: MOCK_CALL_ID,
+  version: "2.0.0",
+  statusCode: 200,
 };
 
 const MOCK_PENDING_RECEIPT: GetCallsStatusResponse = {
-  status: "PENDING",
+  status: "pending",
   receipts: [],
+  atomic: false,
+  chainId: 1,
+  id: MOCK_CALL_ID,
+  version: "2.0.0",
+  statusCode: 100,
 };
 
 const mockGetCallsStatus = vi.spyOn(getCallsStatusExports, "getCallsStatus");
@@ -61,10 +71,10 @@ describe("waitForBundle", () => {
     mockGetCallsStatus.mockResolvedValueOnce(MOCK_SUCCESS_RECEIPT);
 
     // can't `await` here because we still need to be able to increment the block number below
-    const res = waitForBundle({
+    const res = waitForCallsReceipt({
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,
-      bundleId: MOCK_BUNDLE_ID,
+      id: MOCK_CALL_ID,
       wallet,
     });
 
@@ -76,10 +86,10 @@ describe("waitForBundle", () => {
   it("should reject with an error when bundle is not complete after waiting 10 blocks", async () => {
     mockGetCallsStatus.mockRejectedValue(MOCK_PENDING_RECEIPT);
 
-    const result = waitForBundle({
+    const result = waitForCallsReceipt({
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,
-      bundleId: MOCK_BUNDLE_ID,
+      id: MOCK_CALL_ID,
       wallet,
       maxBlocksWaitTime: 10,
     });

package/src/wallets/eip5792/{wait-for-bundle.ts → wait-for-calls-receipt.ts}

@@ -4,20 +4,18 @@ import { watchBlockNumber } from "../../rpc/watchBlockNumber.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { Wallet } from "../interfaces/wallet.js";
 import { getCallsStatus } from "./get-calls-status.js";
-import type { GetCallsStatusResponse, WalletSendCallsId } from "./types.js";
-
+import type { GetCallsStatusResponse } from "./types.js";
 const DEFAULT_MAX_BLOCKS_WAIT_TIME = 100;
 
 const map = new Map<string, Promise<GetCallsStatusResponse>>();
 
-export type WaitForBundleOptions = Prettify<{
-  bundleId: WalletSendCallsId;
-  wallet: Wallet;
+export type WaitForCallsReceiptOptions = Prettify<{
+  id: string;
   client: ThirdwebClient;
   chain: Chain;
+  wallet: Wallet;
   maxBlocksWaitTime?: number;
 }>;
-
 /**
  * Waits for the [EIP-5792](https://eips.ethereum.org/EIPS/eip-5792) bundle to be confirmed.
  *
@@ -30,23 +28,35 @@ export type WaitForBundleOptions = Prettify<{
  * @beta
  * @example
  * ```ts
- * import { waitForBundle } from "thirdweb/wallets/eip5792";
- * const result = await waitForBundle({
+ * import { waitForCallsReceipt } from "thirdweb/wallets/eip5792";
+ * const result = await waitForCallsReceipt({
+ *   client,
+ *   chain,
+ *   wallet,
+ *   id: "0x123...",
+ * });
+ * ```
+ *
+ * Example with useSendCalls:
+ * ```ts
+ * const sendResult = await sendCalls({
  *   client,
  *   chain,
  *   wallet,
- *   bundleId: "0x123...",
+ *   calls: [...],
  * });
+ * const confirmResult = await waitForCallsReceipt(sendResult);
+ * console.log("Transaction confirmed: ", confirmResult.receipts?.[0].transactionHash);
  * ```
  * @extension EIP5792
  */
-export function waitForBundle(
-  options: WaitForBundleOptions,
+export function waitForCallsReceipt(
+  options: WaitForCallsReceiptOptions,
 ): Promise<GetCallsStatusResponse> {
-  const { bundleId, chain, wallet, client } = options;
+  const { id, chain, wallet, client } = options;
 
   const chainId = chain.id;
-  const key = `${chainId}:calls_${bundleId}`;
+  const key = `${chainId}:calls_${id}`;
   const maxBlocksWaitTime =
     options.maxBlocksWaitTime ?? DEFAULT_MAX_BLOCKS_WAIT_TIME;
 
@@ -74,14 +84,14 @@ export function waitForBundle(
           const result = await getCallsStatus({
             wallet,
             client,
-            bundleId,
+            id,
           });
-
-          if (result.status === "CONFIRMED") {
+          if (result.status === "success" || result.status === "failure") {
             // stop the polling
             unwatch();
             // resolve the top level promise with the result
             resolve(result);
+            return;
           }
         } catch {
           // noop, we'll try again on the next blocks