thirdweb 5.97.3 → 5.98.1

package/src/extensions/uniswap/__generated__/ISwapRouter/write/exactOutputSingle.ts

@@ -187,5 +187,7 @@ export function exactOutputSingle(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/uniswap/__generated__/IUniswapV3Factory/write/createPool.ts

@@ -162,5 +162,7 @@ export function createPool(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/uniswap/__generated__/IUniswapV3Factory/write/enableFeeAmount.ts

@@ -144,5 +144,7 @@ export function enableFeeAmount(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/uniswap/__generated__/IUniswapV3Factory/write/setOwner.ts

@@ -131,5 +131,7 @@ export function setOwner(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/castVote.ts

@@ -146,5 +146,7 @@ export function castVote(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/castVoteBySig.ts

@@ -184,5 +184,7 @@ export function castVoteBySig(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/castVoteWithReason.ts

@@ -166,5 +166,7 @@ export function castVoteWithReason(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/castVoteWithReasonAndParams.ts

@@ -180,5 +180,7 @@ export function castVoteWithReasonAndParams(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/castVoteWithReasonAndParamsBySig.ts

@@ -210,5 +210,7 @@ export function castVoteWithReasonAndParamsBySig(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/execute.ts

@@ -175,5 +175,7 @@ export function execute(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/propose.ts

@@ -176,5 +176,7 @@ export function propose(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/relay.ts

@@ -155,5 +155,7 @@ export function relay(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/setProposalThreshold.ts

@@ -140,5 +140,7 @@ export function setProposalThreshold(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/setVotingDelay.ts

@@ -136,5 +136,7 @@ export function setVotingDelay(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/setVotingPeriod.ts

@@ -136,5 +136,7 @@ export function setVotingPeriod(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/extensions/vote/__generated__/Vote/write/updateQuorumNumerator.ts

@@ -140,5 +140,7 @@ export function updateQuorumNumerator(
     nonce: async () => (await asyncOptions()).overrides?.nonce,
     extraGas: async () => (await asyncOptions()).overrides?.extraGas,
     erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+    authorizationList: async () =>
+      (await asyncOptions()).overrides?.authorizationList,
   });
 }

package/src/storage/upload/web-node.ts

@@ -25,6 +25,8 @@ export async function uploadBatch<const TFiles extends UploadableFile[]>(
       body: form,
       requestTimeoutMs:
         client.config?.storage?.fetch?.requestTimeoutMs || 120000,
+      // force auth token usage for storage uploads
+      useAuthToken: true,
     },
   );
 

package/src/transaction/actions/estimate-gas.ts

@@ -2,6 +2,7 @@ import * as ox__Hex from "ox/Hex";
 import { formatTransactionRequest } from "viem";
 import { roundUpGas } from "../../gas/op-gas-fee-reducer.js";
 import { getAddress } from "../../utils/address.js";
+import { hexToBytes } from "../../utils/encoding/to-bytes.js";
 import { resolvePromisedValue } from "../../utils/promise/resolve-promised-value.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
@@ -122,7 +123,6 @@ export async function estimateGas(
           data: encodedData,
           from: fromAddress ? getAddress(fromAddress) : undefined,
           value,
-          // TODO: Remove this casting when we migrate this file to Ox
           authorizationList: authorizationList?.map((auth) => ({
             ...auth,
             r: ox__Hex.fromNumber(auth.r),
@@ -130,6 +130,15 @@ export async function estimateGas(
             nonce: Number(auth.nonce),
             contractAddress: getAddress(auth.address),
           })),
+          ...(authorizationList && authorizationList?.length > 0
+            ? {
+                gas:
+                  minGas(
+                    hexToBytes(encodedData),
+                    BigInt(authorizationList?.length ?? 0),
+                  ) + 100_000n,
+              }
+            : {}),
         }),
       );
 
@@ -147,3 +156,19 @@ export async function estimateGas(
   cache.set(txWithFrom, promise);
   return promise;
 }
+
+// EIP-7623 + EIP-7702 floor calculation
+const TxGas = 21_000n;
+const TxCostFloorPerToken = 10n; // params.TxCostFloorPerToken
+const TxTokenPerNonZero = 4n; // params.TxTokenPerNonZeroByte
+const TxAuthTupleGas = 12_500n;
+
+function minGas(data: Uint8Array, authCount = 0n) {
+  let nz = 0n;
+  for (const b of data) if (b !== 0) nz++;
+  const z = BigInt(data.length) - nz;
+  const tokens = nz * TxTokenPerNonZero + z;
+  const floor = TxGas + tokens * TxCostFloorPerToken;
+  const intrinsic = TxGas + authCount * TxAuthTupleGas;
+  return floor > intrinsic ? floor : intrinsic;
+}

package/src/transaction/prepare-contract-call.ts

@@ -49,6 +49,7 @@ export type PrepareContractCallOptions<
     | "maxFeePerGas"
     | "maxPriorityFeePerGas"
     | "nonce"
+    | "authorizationList"
   > & {
     contract: ThirdwebContract<TAbi>;
     method: TMethod | TPreparedMethod;

package/src/utils/bytecode/resolveImplementation.ts

@@ -48,6 +48,7 @@ export async function resolveImplementation(
 
   // check other proxy types
   let implementationAddress: string | undefined;
+
   if (beacon && beacon !== AddressZero) {
     // In case of a BeaconProxy, it is setup as BeaconProxy --> Beacon --> Implementation
     // Hence we replace the proxy address with Beacon address, and continue further resolving below

package/src/utils/fetch.test.ts

@@ -52,7 +52,7 @@ describe("getClientFetch", () => {
     );
   });
 
-  it("should send a bearer token if secret key is a JWT", () => {
+  it("should NOT send a bearer token if secret key is a JWT", () => {
     vi.spyOn(global, "fetch").mockResolvedValue(new Response());
     const clientFetch = getClientFetch({
       clientId: "test-client-id",
@@ -67,6 +67,28 @@ describe("getClientFetch", () => {
       }),
     );
 
+    // biome-ignore lint/suspicious/noExplicitAny: `any` type ok for tests
+    const headers = (global.fetch as any).mock.calls[0][1].headers;
+    expect(headers.get("authorization")).toBe(null);
+  });
+
+  it("should send a bearer token if secret key is a JWT and useAuthToken is true", () => {
+    vi.spyOn(global, "fetch").mockResolvedValue(new Response());
+    const clientFetch = getClientFetch({
+      clientId: "test-client-id",
+      secretKey: "foo.bar.baz",
+    });
+    clientFetch("https://api.thirdweb.com/test", {
+      useAuthToken: true,
+    });
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.thirdweb.com/test",
+      expect.objectContaining({
+        headers: expect.any(Headers),
+      }),
+    );
+
     // biome-ignore lint/suspicious/noExplicitAny: `any` type ok for tests
     const headers = (global.fetch as any).mock.calls[0][1].headers;
     expect(headers.get("authorization")).toBe("Bearer foo.bar.baz");

package/src/utils/fetch.ts

@@ -22,10 +22,16 @@ export function getClientFetch(client: ThirdwebClient, ecosystem?: Ecosystem) {
    */
   async function fetchWithHeaders(
     url: string | Request,
-    init?: Omit<RequestInit, "signal"> & { requestTimeoutMs?: number },
+    init?: Omit<RequestInit, "signal"> & {
+      requestTimeoutMs?: number;
+      useAuthToken?: boolean;
+    },
   ): Promise<Response> {
-    const { requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT, ...restInit } =
-      init || {};
+    const {
+      requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT,
+      useAuthToken,
+      ...restInit
+    } = init || {};
 
     let headers = restInit.headers
       ? new Headers(restInit.headers)
@@ -41,7 +47,7 @@ export function getClientFetch(client: ThirdwebClient, ecosystem?: Ecosystem) {
       }
       // auth token if secret key === jwt
       const authToken =
-        client.secretKey && isJWT(client.secretKey)
+        useAuthToken && client.secretKey && isJWT(client.secretKey)
           ? client.secretKey
           : undefined;
       // secret key if secret key !== jwt
@@ -64,14 +70,15 @@ export function getClientFetch(client: ThirdwebClient, ecosystem?: Ecosystem) {
         if (client.teamId) {
           headers.set("x-team-id", client.teamId);
         }
-      }
-
-      if (secretKey) {
-        headers.set("x-secret-key", secretKey);
-      }
+      } else {
+        // only set secret key or client id if we are NOT using the auth token!
+        if (secretKey) {
+          headers.set("x-secret-key", secretKey);
+        }
 
-      if (clientId) {
-        headers.set("x-client-id", clientId);
+        if (clientId) {
+          headers.set("x-client-id", clientId);
+        }
       }
 
       if (ecosystem) {

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.97.3";
+export const version = "5.98.1";

package/src/wallets/engine/index.ts

@@ -96,13 +96,20 @@ export function engineAccount(options: EngineAccountOptions): Account {
       const ENGINE_URL = new URL(engineUrl);
       ENGINE_URL.pathname = `/backend-wallet/${transaction.chainId}/send-transaction`;
 
-      const engineData: Record<string, string | undefined> = {
+      const engineData: Record<string, unknown> = {
         // add to address if we have it (is optional to pass to engine)
         toAddress: transaction.to || undefined,
         // engine wants a hex string here so we serialize it
         data: transaction.data || "0x",
         // value is always required
-        value: toHex(transaction.value ?? 0n),
+        value: transaction.value ?? 0n,
+        // optional authorization list
+        authorizationList: transaction.authorizationList,
+
+        txOverrides: {
+          gas: transaction.gas,
+          value: transaction.value,
+        },
       };
 
       // TODO: gas overrides etc?

package/src/wallets/in-app/core/actions/sign-authorization.enclave.ts

@@ -0,0 +1,59 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { AuthorizationRequest } from "../../../../transaction/actions/eip7702/authorization.js";
+import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import { stringify } from "../../../../utils/json.js";
+import type { ClientScopedStorage } from "../authentication/client-scoped-storage.js";
+
+export async function signAuthorization({
+  client,
+  payload,
+  storage,
+}: {
+  client: ThirdwebClient;
+  payload: AuthorizationRequest;
+  storage: ClientScopedStorage;
+}) {
+  const authToken = await storage.getAuthCookie();
+  const ecosystem = storage.ecosystem;
+  const clientFetch = getClientFetch(client, ecosystem);
+
+  if (!authToken) {
+    throw new Error("No auth token found when signing message");
+  }
+
+  const body = {
+    address: payload.address,
+    chainId: payload.chainId,
+    nonce: Number(payload.nonce),
+  };
+
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-authorization`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+      body: stringify(body),
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to sign message - ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const signedAuthorization = (await response.json()) as {
+    r: string;
+    s: string;
+    yParity: string;
+    nonce: string;
+    address: string;
+    chainId: string;
+  };
+  return signedAuthorization;
+}

package/src/wallets/in-app/core/actions/sign-transaction.enclave.ts

@@ -11,7 +11,7 @@ export async function signTransaction({
   storage,
 }: {
   client: ThirdwebClient;
-  payload: Record<string, Hex | number | undefined>;
+  payload: Record<string, unknown>;
   storage: ClientScopedStorage;
 }) {
   const authToken = await storage.getAuthCookie();

package/src/wallets/in-app/core/eip7702/minimal-account.ts

@@ -0,0 +1,208 @@
+import type { Definition, TypedData } from "ox/TypedData";
+import type { Hex, SignableMessage } from "viem";
+import { getCachedChain } from "../../../../chains/utils.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getBytecode } from "../../../../contract/actions/get-bytecode.js";
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../../contract/contract.js";
+import { execute } from "../../../../extensions/erc7702/__generated__/MinimalAccount/write/execute.js";
+import type { SignedAuthorization } from "../../../../transaction/actions/eip7702/authorization.js";
+import { toSerializableTransaction } from "../../../../transaction/actions/to-serializable-transaction.js";
+import type { SendTransactionResult } from "../../../../transaction/types.js";
+import { getAddress } from "../../../../utils/address.js";
+import { randomBytesHex } from "../../../../utils/random.js";
+import type {
+  Account,
+  SendTransactionOption,
+} from "../../../interfaces/wallet.js";
+import {
+  executeWithSignature,
+  getQueuedTransactionHash,
+} from "../../../smart/lib/bundler.js";
+import type { BundlerOptions } from "../../../smart/types.js";
+
+const MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS =
+  "0xbaC7e770af15d130Cd72838ff386f14FBF3e9a3D";
+
+export const create7702MinimalAccount = (args: {
+  client: ThirdwebClient;
+  adminAccount: Account;
+  sponsorGas?: boolean;
+}): Account => {
+  const { client, adminAccount, sponsorGas } = args;
+
+  const _sendTxWithAuthorization = async (txs: SendTransactionOption[]) => {
+    const firstTx = txs[0];
+    if (!firstTx) {
+      throw new Error("No transactions provided");
+    }
+    const chain = getCachedChain(firstTx.chainId);
+    const eoaContract = getContract({
+      address: adminAccount.address,
+      client,
+      chain,
+    });
+    // check if account has been delegated already
+    let authorization: SignedAuthorization | undefined = undefined;
+    const isMinimalAccount = await is7702MinimalAccount(eoaContract);
+    if (!isMinimalAccount) {
+      // if not, sign authorization
+      const nonce = firstTx.nonce
+        ? BigInt(firstTx.nonce) + (sponsorGas ? 0n : 1n)
+        : 0n; // TODO (7702): get remote nonce if not provided, should be in the tx though
+      const auth = await adminAccount.signAuthorization?.({
+        address: MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS,
+        chainId: firstTx.chainId,
+        nonce,
+      });
+      if (!auth) {
+        throw new Error("Failed to sign authorization");
+      }
+      authorization = auth;
+    }
+    if (sponsorGas) {
+      // send transaction from executor, needs signature
+      const wrappedCalls = {
+        calls: txs.map((tx) => ({
+          target: getAddress(tx.to ?? ""), // will throw if undefined address
+          value: tx.value ?? 0n,
+          data: tx.data ?? "0x",
+        })),
+        uid: randomBytesHex(),
+      };
+      const signature = await adminAccount.signTypedData({
+        domain: {
+          name: "MinimalAccount",
+          version: "1",
+          chainId: firstTx.chainId,
+          verifyingContract: eoaContract.address,
+        },
+        types: {
+          WrappedCalls: [
+            { name: "calls", type: "Call[]" },
+            { name: "uid", type: "bytes32" },
+          ],
+          Call: [
+            { name: "target", type: "address" },
+            { name: "value", type: "uint256" },
+            { name: "data", type: "bytes" },
+          ],
+        },
+        message: wrappedCalls,
+        primaryType: "WrappedCalls",
+      });
+
+      const result = await executeWithSignature({
+        eoaAddress: getAddress(adminAccount.address),
+        wrappedCalls,
+        signature,
+        authorization,
+        options: {
+          client,
+          chain: getCachedChain(firstTx.chainId),
+        },
+      });
+
+      const transactionHash = await waitForTransactionHash({
+        options: {
+          client,
+          chain: getCachedChain(firstTx.chainId),
+        },
+        transactionId: result.transactionId,
+      });
+      return {
+        transactionHash,
+      };
+    }
+    // send transaction from EOA
+    // wrap txs in a single execute call to the MinimalAccount
+    const executeTx = execute({
+      contract: eoaContract,
+      calls: txs.map((tx) => ({
+        target: tx.to ?? "",
+        value: tx.value ?? 0n,
+        data: tx.data ?? "0x",
+      })),
+      overrides: {
+        value: txs.reduce((acc, tx) => acc + (tx.value ?? 0n), 0n),
+        authorizationList: authorization ? [authorization] : undefined,
+      },
+    });
+    // re-estimate gas for the entire batch + authorization
+    const serializedTx = await toSerializableTransaction({
+      transaction: executeTx,
+      from: adminAccount.address,
+    });
+    return adminAccount.sendTransaction(serializedTx);
+  };
+
+  const minimalAccount: Account = {
+    address: adminAccount.address,
+    sendTransaction: async (
+      tx: SendTransactionOption,
+    ): Promise<SendTransactionResult> => {
+      return _sendTxWithAuthorization([tx]);
+    },
+    sendBatchTransaction: async (
+      txs: SendTransactionOption[],
+    ): Promise<SendTransactionResult> => {
+      return _sendTxWithAuthorization(txs);
+    },
+    signMessage: ({
+      message,
+      originalMessage,
+      chainId,
+    }: {
+      message: SignableMessage;
+      originalMessage?: string;
+      chainId?: number;
+    }): Promise<Hex> =>
+      adminAccount.signMessage({ message, originalMessage, chainId }),
+    signTypedData: <
+      const typedData extends TypedData | Record<string, unknown>,
+      primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+    >(
+      _typedData: Definition<typedData, primaryType>,
+    ): Promise<Hex> => adminAccount.signTypedData(_typedData),
+  };
+  return minimalAccount;
+};
+
+async function is7702MinimalAccount(
+  eoaContract: ThirdwebContract,
+): Promise<boolean> {
+  const code = await getBytecode(eoaContract);
+  const isDelegated = code.length > 0 && code.startsWith("0xef0100");
+  const target = `0x${code.slice(8, 48)}`;
+  return (
+    isDelegated &&
+    target.toLowerCase() ===
+      MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS.toLowerCase()
+  );
+}
+
+async function waitForTransactionHash(args: {
+  options: BundlerOptions;
+  transactionId: string;
+  timeoutMs?: number;
+  intervalMs?: number;
+}): Promise<Hex> {
+  const timeout = args.timeoutMs || 120000; // 2mins
+  const interval = args.intervalMs || 1000; // 1s
+  const endtime = Date.now() + timeout;
+  while (Date.now() < endtime) {
+    const result = await getQueuedTransactionHash({
+      options: args.options,
+      transactionId: args.transactionId,
+    });
+    if (result.transactionHash) {
+      return result.transactionHash;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error(
+    `Timeout waiting for transaction to be mined on chain ${args.options.chain.id} with transactionId: ${args.transactionId}`,
+  );
+}