[SDK] Feature: Basic EIP7702 Support (#5801)

<!-- start pr-codex -->

## PR-Codex overview
This PR introduces beta support for `EIP-7702` authorization lists, enhancing transaction handling and signing within the `thirdweb` library.

### Detailed summary
- Added `style` configuration in `biome.json`.
- Introduced `signAuthorization` function for EIP-7702 authorizations.
- Updated transaction preparation to include `authorizationList`.
- Added tests for `signAuthorization` and transaction serialization.
- Modified `serializeTransaction` to handle EIP-7702 transactions.
- Enhanced gas estimation and transaction preparation functions to support authorization lists.

> ✨ Ask PR-Codex anything about this PR by commenting with `/codex {your question}`

<!-- end pr-codex -->

Author: gregfromstl

.changeset/clever-beds-knock.md

@@ -0,0 +1,32 @@
+---
+"thirdweb": minor
+---
+
+Feature: Adds beta support for EIP-7702 authorization lists
+
+```ts
+import { prepareTransaction, sendTransaction, signAuthorization } from "thirdweb";
+
+const authorization = await signAuthorization({
+    request: {
+        address: "0x...",
+        chainId: 911867,
+        nonce: 100n,
+    },
+    account: myAccount,
+});
+
+const transaction = prepareTransaction({
+    chain: ANVIL_CHAIN,
+    client: TEST_CLIENT,
+    value: 100n,
+    to: TEST_WALLET_B,
+    authorizationList: [authorization],
+});
+
+const res = await sendTransaction({
+    account,
+    transaction,
+});
+```
+

packages/thirdweb/biome.json

@@ -23,6 +23,9 @@
         "rules": {
           "nursery": {
             "noProcessEnv": "off"
+          },
+          "style": {
+            "noUnusedTemplateLiteral": "off"
           }
         }
       }

packages/thirdweb/src/adapters/ethers5.ts

@@ -483,7 +483,7 @@ export async function toEthersSigner(
 
       const response: ethers5.ethers.providers.TransactionResponse = {
         ...serialized,
-        nonce: serialized.nonce ?? 0,
+        nonce: Number(serialized.nonce ?? 0),
         from: account.address,
         maxFeePerGas: serialized.maxFeePerGas
           ? ethers.BigNumber.from(serialized.maxFeePerGas)

packages/thirdweb/src/exports/thirdweb.ts

@@ -303,4 +303,12 @@ export {
   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";

packages/thirdweb/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";

packages/thirdweb/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({

packages/thirdweb/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,
+      }
+    `);
+  });
+});

packages/thirdweb/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);
+}

packages/thirdweb/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);
       }

packages/thirdweb/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