thirdweb 5.81.0 → 5.82.0

package/src/auth/verify-hash.ts

@@ -129,8 +129,7 @@ export async function verifyHash({
   try {
     const result = await eth_call(rpcRequest, verificationData);
     return hexToBool(result);
-  } catch (err) {
-    console.error("Error verifying ERC-6492 signature", err);
+  } catch {
     // Some chains do not support the eth_call simulation and will fail, so we fall back to regular EIP1271 validation
     const validEip1271 = await verifyEip1271Signature({
       hash,
@@ -154,7 +153,7 @@ export async function verifyHash({
 }
 
 const EIP_1271_MAGIC_VALUE = "0x1626ba7e";
-async function verifyEip1271Signature({
+export async function verifyEip1271Signature({
   hash,
   signature,
   contract,
@@ -163,10 +162,14 @@ async function verifyEip1271Signature({
   signature: Hex;
   contract: ThirdwebContract;
 }): Promise<boolean> {
-  const result = await isValidSignature({
-    hash,
-    signature,
-    contract,
-  });
-  return result === EIP_1271_MAGIC_VALUE;
+  try {
+    const result = await isValidSignature({
+      hash,
+      signature,
+      contract,
+    });
+    return result === EIP_1271_MAGIC_VALUE;
+  } catch {
+    return false;
+  }
 }

package/src/contract/types.ts

@@ -0,0 +1,8 @@
+import type { Abi, AbiFunction } from "abitype";
+import type { ThirdwebContract } from "./contract.js";
+
+export type AbiOfLength<TLength> = { length: TLength };
+
+export type AsyncGetAbiFunctionFromContract<TAbi extends Abi> = (
+  contract: ThirdwebContract<TAbi>,
+) => Promise<AbiFunction>;

package/src/exports/thirdweb.ts

@@ -302,3 +302,13 @@ export {
   type VerifyTypedDataParams,
   verifyTypedData,
 } from "../auth/verify-typed-data.js";
+
+/**
+ * EIP-7702
+ */
+export type {
+  AuthorizationRequest,
+  SignedAuthorization,
+} from "../transaction/actions/eip7702/authorization.js";
+export { signAuthorization } from "../transaction/actions/eip7702/authorization.js";
+export { deploySmartAccount } from "../wallets/smart/lib/signing.js";

package/src/exports/transaction.ts

@@ -78,3 +78,12 @@ export type { GaslessOptions } from "../transaction/actions/gasless/types.js";
 export type { EngineOptions } from "../transaction/actions/gasless/providers/engine.js";
 export type { OpenZeppelinOptions } from "../transaction/actions/gasless/providers/openzeppelin.js";
 export type { BiconomyOptions } from "../transaction/actions/gasless/providers/biconomy.js";
+
+/**
+ * EIP-7702
+ */
+export type {
+  AuthorizationRequest,
+  SignedAuthorization,
+} from "../transaction/actions/eip7702/authorization.js";
+export { signAuthorization } from "../transaction/actions/eip7702/authorization.js";

package/src/exports/wallets.ts

@@ -160,3 +160,5 @@ export * as EIP1193 from "../adapters/eip1193/index.js";
 export { injectedProvider } from "../wallets/injected/mipdStore.js";
 
 export type { ConnectionManager } from "../wallets/manager/index.js";
+
+export { deploySmartAccount } from "../wallets/smart/lib/signing.js";

package/src/extensions/erc721/lazyMinting/read/getBatchesToReveal.ts

@@ -15,7 +15,7 @@ import * as TokenURI from "../../__generated__/IERC721A/read/tokenURI.js";
 export interface BatchToReveal {
   batchId: bigint;
   batchUri: string;
-  placeholderMetadata: NFTMetadata;
+  placeholderMetadata: NFTMetadata | undefined;
 }
 
 /**
@@ -82,7 +82,7 @@ export async function getBatchesToReveal(
         tokenId: BigInt(i),
         tokenUri: uri,
         client: options.contract.client,
-      });
+      }).catch(() => undefined);
     }),
   );
 

package/src/extensions/types.ts

@@ -0,0 +1,6 @@
+import type { Abi } from "abitype";
+import type { BaseTransactionOptions } from "../transaction/types.js";
+
+export type Extension<TAbi extends Abi, TParams extends object, TResult> = (
+  options: BaseTransactionOptions<TParams, TAbi>,
+) => Promise<TResult>;

package/src/gas/estimate-l1-fee.ts

@@ -1,8 +1,8 @@
-import { serializeTransaction } from "viem";
 import { getContract } from "../contract/contract.js";
 import { toSerializableTransaction } from "../transaction/actions/to-serializable-transaction.js";
 import type { PreparedTransaction } from "../transaction/prepare-transaction.js";
 import { readContract } from "../transaction/read-contract.js";
+import { serializeTransaction } from "../transaction/serialize-transaction.js";
 
 type EstimateL1FeeOptions = {
   transaction: PreparedTransaction;
@@ -29,8 +29,7 @@ export async function estimateL1Fee(options: EstimateL1FeeOptions) {
     transaction,
   });
   const serialized = serializeTransaction({
-    ...serializableTx,
-    type: "eip1559",
+    transaction: serializableTx,
   });
   //serializeTransaction(transaction);
   return readContract({

package/src/react/core/hooks/contract/useReadContract.ts

@@ -4,7 +4,11 @@ import {
   useQuery,
 } from "@tanstack/react-query";
 import type { Abi, AbiFunction, ExtractAbiFunctionNames } from "abitype";
-import type { ThirdwebContract } from "../../../../contract/contract.js";
+import type {
+  AbiOfLength,
+  AsyncGetAbiFunctionFromContract,
+} from "../../../../contract/types.js";
+import type { Extension } from "../../../../extensions/types.js";
 import {
   type ReadContractOptions,
   type ReadContractResult,
@@ -17,17 +21,16 @@ import type {
 import type { PreparedMethod } from "../../../../utils/abi/prepare-method.js";
 import { getFunctionId } from "../../../../utils/function-id.js";
 import { stringify } from "../../../../utils/json.js";
-
-type PickedQueryOptions = {
-  enabled?: boolean;
-  refetchInterval?: number;
-  retry?: number;
-};
+import type {
+  PickedOnceQueryOptions,
+  WithPickedOnceQueryOptions,
+} from "../types.js";
 
 /**
  * A hook to read state from a contract that automatically updates when the contract changes.
  *
- * You can use raw read calls or read [extensions](https://portal.thirdweb.com/react/v5/extensions) to read from a contract.
+ * You can use raw read calls or read [extensions](https://portal.thirdweb.com/react/v5/extensions) to read from a
+ * contract.
  *
  * @param options - The options for reading from a contract
  * @returns a UseQueryResult object.
@@ -52,20 +55,19 @@ type PickedQueryOptions = {
  * @contract
  */
 export function useReadContract<
-  const abi extends Abi,
-  const method extends abi extends { length: 0 }
+  const TAbi extends Abi,
+  const TMethod extends TAbi extends AbiOfLength<0>
     ? AbiFunction | string
-    : ExtractAbiFunctionNames<abi>,
+    : ExtractAbiFunctionNames<TAbi>,
 >(
-  options: ReadContractOptions<abi, method> & {
-    queryOptions?: PickedQueryOptions;
-  },
+  options: WithPickedOnceQueryOptions<ReadContractOptions<TAbi, TMethod>>,
 ): UseQueryResult<
-  ReadContractResult<PreparedMethod<ParseMethod<abi, method>>[2]>
+  ReadContractResult<PreparedMethod<ParseMethod<TAbi, TMethod>>[2]>
 >;
 /**
  * A hook to read state from a contract that automatically updates when the contract changes.
- * You can use raw read calls or read [extensions](https://portal.thirdweb.com/react/v5/extensions) to read from a contract.
+ * You can use raw read calls or read [extensions](https://portal.thirdweb.com/react/v5/extensions) to read from a
+ * contract.
  *
  * @param extension - An extension to call.
  * @param options - The read extension params.
@@ -82,38 +84,42 @@ export function useReadContract<
  * ```
  */
 export function useReadContract<
-  const abi extends Abi,
-  const params extends object,
-  result,
+  const TAbi extends Abi,
+  const TParams extends object,
+  TResult,
 >(
-  extension: (options: BaseTransactionOptions<params, abi>) => Promise<result>,
-  options: BaseTransactionOptions<params, abi> & {
-    queryOptions?: PickedQueryOptions;
-  },
-): UseQueryResult<result>;
+  extension: Extension<TAbi, TParams, TResult>,
+  options: WithPickedOnceQueryOptions<BaseTransactionOptions<TParams, TAbi>>,
+): UseQueryResult<TResult>;
 
 export function useReadContract<
-  const abi extends Abi,
-  const method extends abi extends {
-    length: 0;
-  }
-    ?
-        | AbiFunction
-        | `function ${string}`
-        | ((contract: ThirdwebContract<abi>) => Promise<AbiFunction>)
-    : ExtractAbiFunctionNames<abi>,
-  const params extends object,
-  result,
+  const TAbi extends Abi,
+  const TMethod extends TAbi extends AbiOfLength<0>
+    ? AbiFunction | `function ${string}` | AsyncGetAbiFunctionFromContract<TAbi>
+    : ExtractAbiFunctionNames<TAbi>,
+  const TParams extends object,
+  TResult,
 >(
   extensionOrOptions:
-    | ((options: BaseTransactionOptions<params, abi>) => Promise<result>)
-    | (ReadContractOptions<abi, method> & {
-        queryOptions?: PickedQueryOptions;
-      }),
-  options?: BaseTransactionOptions<params, abi> & {
-    queryOptions?: PickedQueryOptions;
-  },
+    | Extension<TAbi, TParams, TResult>
+    | WithPickedOnceQueryOptions<ReadContractOptions<TAbi, TMethod>>,
+  options?: WithPickedOnceQueryOptions<BaseTransactionOptions<TParams, TAbi>>,
 ) {
+  type QueryKey = readonly [
+    "readContract",
+    number | string,
+    string,
+    string | PreparedMethod<ParseMethod<TAbi, TMethod>>,
+    string,
+  ];
+  type QueryFn = () => Promise<
+    TResult | ReadContractResult<PreparedMethod<ParseMethod<TAbi, TMethod>>[2]>
+  >;
+
+  let queryKey: QueryKey | undefined;
+  let queryFn: QueryFn | undefined;
+  let queryOpts: PickedOnceQueryOptions | undefined;
+
   // extension case
   if (typeof extensionOrOptions === "function") {
     if (!options) {
@@ -122,46 +128,49 @@ export function useReadContract<
       ) as never;
     }
     const { queryOptions, contract, ...params } = options;
+    queryOpts = queryOptions;
 
-    const query = defineQuery({
-      queryKey: [
-        "readContract",
-        contract.chain.id,
-        contract.address,
-        getFunctionId(extensionOrOptions),
-        stringify(params),
-      ] as const,
-      // @ts-expect-error - TODO: clean up the type issues here
-      queryFn: () => extensionOrOptions({ ...params, contract }),
-      ...queryOptions,
-    });
+    queryKey = [
+      "readContract",
+      contract.chain.id,
+      contract.address,
+      getFunctionId(extensionOrOptions),
+      stringify(params),
+    ] as const;
 
-    // TODO - FIX LATER
-    // biome-ignore lint/correctness/useHookAtTopLevel: <explanation>
-    return useQuery(query);
+    queryFn = () =>
+      extensionOrOptions({
+        ...(params as TParams),
+        contract,
+      });
   }
   // raw tx case
   if ("method" in extensionOrOptions) {
     const { queryOptions, ...tx } = extensionOrOptions;
+    queryOpts = queryOptions;
 
-    const query = defineQuery({
-      queryKey: [
-        "readContract",
-        tx.contract.chain.id,
-        tx.contract.address,
-        tx.method,
-        stringify(tx.params),
-      ] as const,
-      queryFn: () => readContract(extensionOrOptions),
-      ...queryOptions,
-    });
+    queryKey = [
+      "readContract",
+      tx.contract.chain.id,
+      tx.contract.address,
+      tx.method,
+      stringify(tx.params),
+    ] as const;
+
+    queryFn = () => readContract(extensionOrOptions);
+  }
 
-    // TODO - FIX LATER
-    // biome-ignore lint/correctness/useHookAtTopLevel: <explanation>
-    return useQuery(query);
+  if (!queryKey || !queryFn) {
+    throw new Error(
+      `Invalid "useReadContract" options. Expected either a read extension or a transaction object.`,
+    ) as never;
   }
 
-  throw new Error(
-    `Invalid "useReadContract" options. Expected either a read extension or a transaction object.`,
-  ) as never;
+  return useQuery(
+    defineQuery({
+      queryKey: queryKey as QueryKey,
+      queryFn: queryFn as QueryFn,
+      ...(queryOpts ?? {}),
+    }),
+  );
 }

package/src/react/core/hooks/types.ts

@@ -0,0 +1,13 @@
+import type { Prettify } from "../../../utils/type-utils.js";
+
+type BasePickedQueryOptions<T = object> = T & {
+  enabled?: boolean;
+};
+
+export type PickedOnceQueryOptions = Prettify<
+  BasePickedQueryOptions & { refetchInterval?: number; retry?: number }
+>;
+
+export type WithPickedOnceQueryOptions<T> = T & {
+  queryOptions?: PickedOnceQueryOptions;
+};

package/src/transaction/actions/eip7702/authorization.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { TEST_WALLET_B } from "~test/addresses.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { signAuthorization } from "./authorization.js";
+
+describe("signAuthorization", () => {
+  it("should sign an authorization", async () => {
+    const authorization = await signAuthorization({
+      account: TEST_ACCOUNT_A,
+      request: {
+        address: TEST_WALLET_B,
+        chainId: 911867,
+        nonce: 0n,
+      },
+    });
+    expect(authorization).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000002",
+        "chainId": 911867,
+        "nonce": 0n,
+        "r": 3720526934953059641417422884731844424204826752871127418111522219225437830766n,
+        "s": 23451045058292828843243765241045958975073226494910356096978666517928790374894n,
+        "yParity": 1,
+      }
+    `);
+  });
+});

package/src/transaction/actions/eip7702/authorization.ts

@@ -0,0 +1,58 @@
+import type * as ox__Authorization from "ox/Authorization";
+import type { Address } from "../../../utils/address.js";
+import type { Account } from "../../../wallets/interfaces/wallet.js";
+
+/**
+ * An EIP-7702 authorization object fully prepared and ready for signing.
+ *
+ * @beta
+ * @transaction
+ */
+export type AuthorizationRequest = {
+  address: Address;
+  chainId: number;
+  nonce: bigint;
+};
+
+/**
+ * Represents a signed EIP-7702 authorization object.
+ *
+ * @beta
+ * @transaction
+ */
+export type SignedAuthorization = ox__Authorization.ListSigned[number];
+
+/**
+ * Sign the given EIP-7702 authorization object.
+ * @param options - The options for `signAuthorization`
+ * Refer to the type [`SignAuthorizationOptions`](https://portal.thirdweb.com/references/typescript/v5/SignAuthorizationOptions)
+ * @returns The signed authorization object
+ *
+ * ```ts
+ * import { signAuthorization } from "thirdweb";
+ *
+ * const authorization = await signAuthorization({
+ *     request: {
+ *         address: "0x...",
+ *         chainId: 911867,
+ *         nonce: 100n,
+ *     },
+ *     account: myAccount,
+ * });
+ * ```
+ *
+ * @beta
+ * @transaction
+ */
+export async function signAuthorization(options: {
+  account: Account;
+  request: AuthorizationRequest;
+}): Promise<SignedAuthorization> {
+  const { account, request } = options;
+  if (typeof account.signAuthorization === "undefined") {
+    throw new Error(
+      "This account type does not yet support signing EIP-7702 authorizations",
+    );
+  }
+  return account.signAuthorization(request);
+}

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

@@ -1,3 +1,4 @@
+import * as ox__Hex from "ox/Hex";
 import { formatTransactionRequest } from "viem";
 import { roundUpGas } from "../../gas/op-gas-fee-reducer.js";
 import { resolvePromisedValue } from "../../utils/promise/resolve-promised-value.js";
@@ -18,6 +19,8 @@ export type EstimateGasOptions = Prettify<
     | {
         /**
          * The account the transaction would be sent from.
+         *
+         * @deprecated Use `from` instead
          */
         account: Account;
         from?: never;
@@ -27,7 +30,7 @@ export type EstimateGasOptions = Prettify<
         /**
          * The address the transaction would be sent from.
          */
-        from?: string;
+        from?: string | Account;
       }
   )
 >;
@@ -60,8 +63,11 @@ export async function estimateGas(
   // 1. the user specified from address
   // 2. the passed in account address
   // 3. the passed in wallet's account address
-  const from = options.from ?? options.account?.address ?? undefined;
-  const txWithFrom = { ...options.transaction, from };
+  const fromAddress =
+    typeof options.from === "string"
+      ? (options.from ?? undefined)
+      : (options.from?.address ?? options.account?.address);
+  const txWithFrom = { ...options.transaction, from: fromAddress };
   if (cache.has(txWithFrom)) {
     // biome-ignore lint/style/noNonNullAssertion: the `has` above ensures that this will always be set
     return cache.get(txWithFrom)!;
@@ -92,11 +98,13 @@ export async function estimateGas(
 
     // load up encode function if we need it
     const { encode } = await import("./encode.js");
-    const [encodedData, toAddress, value] = await Promise.all([
-      encode(options.transaction),
-      resolvePromisedValue(options.transaction.to),
-      resolvePromisedValue(options.transaction.value),
-    ]);
+    const [encodedData, toAddress, value, authorizationList] =
+      await Promise.all([
+        encode(options.transaction),
+        resolvePromisedValue(options.transaction.to),
+        resolvePromisedValue(options.transaction.value),
+        resolvePromisedValue(options.transaction.authorizationList),
+      ]);
 
     // load up the rpc client and the estimateGas function if we need it
     const [{ getRpcClient }, { eth_estimateGas }] = await Promise.all([
@@ -111,10 +119,19 @@ export async function estimateGas(
         formatTransactionRequest({
           to: toAddress,
           data: encodedData,
-          from,
+          from: fromAddress,
           value,
+          // TODO: Remove this casting when we migrate this file to Ox
+          authorizationList: authorizationList?.map((auth) => ({
+            ...auth,
+            r: ox__Hex.fromNumber(auth.r),
+            s: ox__Hex.fromNumber(auth.s),
+            nonce: Number(auth.nonce),
+            contractAddress: auth.address,
+          })),
         }),
       );
+
       if (options.transaction.chain.experimental?.increaseZeroByteCount) {
         gas = roundUpGas(gas);
       }

package/src/transaction/actions/send-transaction.ts

@@ -110,6 +110,37 @@ export interface SendTransactionOptions {
  * });
  * ```
  *
+ * ### Send an EIP-7702 Transaction
+ *
+ * **Note: This feature is in beta and is subject to breaking changes**
+ *
+ * ```ts
+ * import { sendTransaction, prepareTransaction, signAuthorization } from "thirdweb";
+ * import { sepolia } from "thirdweb/chains";
+ *
+ * const authorization = await signAuthorization({
+ *   request: {
+ *     address: "0x...",
+ *     chainId: 1,
+ *     nonce: 0n,
+ *   },
+ *   account: myAccount,
+ * });
+ *
+ * const transaction = prepareTransaction({
+ *   chain: sepolia,
+ *   client: client,
+ *   to: "0x...",
+ *   value: 0n,
+ *   authorizationList: [authorization],
+ * });
+ *
+ * const { transactionHash } = await sendTransaction({
+ *  account,
+ *  transaction,
+ * });
+ * ```
+ *
  * ### Gasless usage with [thirdweb Engine](https://portal.thirdweb.com/engine)
  * ```ts
  * const { transactionHash } = await sendTransaction({
@@ -166,9 +197,8 @@ export async function sendTransaction(
 
   const serializableTransaction = await toSerializableTransaction({
     transaction: transaction,
-    from: account.address,
+    from: account,
   });
-
   // branch for gasless transactions
   if (gasless) {
     // lazy load the gasless tx function because it's only needed for gasless transactions

package/src/transaction/actions/to-serializable-transaction.test.ts

@@ -3,6 +3,7 @@ import { beforeAll, describe, expect, test } from "vitest";
 import { TEST_WALLET_B } from "../../../test/src/addresses.js";
 import { FORKED_ETHEREUM_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 { arbitrumSepolia } from "../../chains/chain-definitions/arbitrum-sepolia.js";
 import { toWei } from "../../utils/units.js";
 import {
@@ -10,6 +11,7 @@ import {
   prepareTransaction,
 } from "../prepare-transaction.js";
 import { serializeTransaction } from "../serialize-transaction.js";
+import { signAuthorization } from "./eip7702/authorization.js";
 import { toSerializableTransaction } from "./to-serializable-transaction.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("toSerializableTransaction", () => {
@@ -272,6 +274,72 @@ describe.runIf(process.env.TW_SECRET_KEY)("toSerializableTransaction", () => {
     });
   });
 
+  describe("authorizations", () => {
+    test("should be able to be set", async () => {
+      const authorization = await signAuthorization({
+        account: TEST_ACCOUNT_A,
+        request: {
+          address: TEST_WALLET_B,
+          chainId: 1,
+          nonce: 100n,
+        },
+      });
+
+      const serializableTransaction = await toSerializableTransaction({
+        transaction: {
+          ...transaction,
+          authorizationList: [authorization],
+        },
+        from: TEST_ACCOUNT_A,
+      });
+
+      expect(serializableTransaction.authorizationList).toMatchInlineSnapshot(`
+        [
+          {
+            "address": "0x0000000000000000000000000000000000000002",
+            "chainId": 1,
+            "nonce": 100n,
+            "r": 80806665504145908662094143605220407474886149466352261863122583017203514896219n,
+            "s": 35406481756212480507222011619049260135807579374282360733409834151386668114999n,
+            "yParity": 1,
+          },
+        ]
+      `);
+    });
+
+    test("should be able to be a promised value", async () => {
+      const authorization = await signAuthorization({
+        account: TEST_ACCOUNT_A,
+        request: {
+          address: TEST_WALLET_B,
+          chainId: 1,
+          nonce: 100n,
+        },
+      });
+
+      const serializableTransaction = await toSerializableTransaction({
+        transaction: {
+          ...transaction,
+          authorizationList: async () => Promise.resolve([authorization]),
+        },
+        from: TEST_ACCOUNT_A,
+      });
+
+      expect(serializableTransaction.authorizationList).toMatchInlineSnapshot(`
+        [
+          {
+            "address": "0x0000000000000000000000000000000000000002",
+            "chainId": 1,
+            "nonce": 100n,
+            "r": 80806665504145908662094143605220407474886149466352261863122583017203514896219n,
+            "s": 35406481756212480507222011619049260135807579374282360733409834151386668114999n,
+            "yParity": 1,
+          },
+        ]
+      `);
+    });
+  });
+
   describe("extraGas override", () => {
     let gas: bigint;
     beforeAll(() => {