feat(sdk): basic eip7702 support

Author: gregfromstl

.changeset/clever-beds-knock.md

@@ -0,0 +1,54 @@
+---
+"thirdweb": minor
+---
+
+Feature: Adds beta support for EIP-7702 authorization lists
+
+```ts
+import { prepareTransaction, sendTransaction } from "thirdweb";
+
+const transaction = prepareTransaction({
+    chain: ANVIL_CHAIN,
+    client: TEST_CLIENT,
+    value: 100n,
+    to: TEST_WALLET_B,
+    authorizations: [
+        {
+            address: "0x...",
+            chainId: 1,
+            nonce: 420n,
+        },
+    ],
+});
+
+const res = await sendTransaction({
+    account,
+    transaction,
+});
+```
+
+You can access the underlying authorization signing functions like so:
+
+```ts
+import { signAuthorization, signedAuthorizations } from "thirdweb";
+
+const signedAuthorization = await signAuthorization({
+    authorization: {
+        address: "0x...",
+        chainId: 1,
+        nonce: 420n,
+    },
+    account: myAccount,
+});
+
+const signedAuthorizations = await signedAuthorizations({
+    authorizations: [
+        {
+            address: "0x...",
+            chainId: 1,
+            nonce: 420n,
+        },
+    ],
+    account: myAccount,
+});
+```

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/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.ts

@@ -0,0 +1,17 @@
+import type * as ox__Authorization from "ox/Authorization";
+
+/**
+ * Represents an EIP-7702 authorization object prior to being signed.
+ *
+ * @beta
+ * @transaction
+ */
+export type Authorization = ox__Authorization.List<false>[number];
+
+/**
+ * Represents a signed EIP-7702 authorization object.
+ *
+ * @beta
+ * @transaction
+ */
+export type SignedAuthorization = ox__Authorization.ListSigned[number];

packages/thirdweb/src/transaction/actions/eip7702/sign-authorization.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import {
+  TEST_ACCOUNT_A,
+  TEST_ACCOUNT_B,
+  TEST_ACCOUNT_C,
+} from "../../../../test/src/test-wallets.js";
+import type { Authorization } from "./authorization.js";
+import { signAuthorization, signAuthorizations } from "./sign-authorization.js";
+
+describe("signAuthorization", () => {
+  it("should sign a single authorization", async () => {
+    const signedAuth = await signAuthorization({
+      authorization: {
+        address: TEST_ACCOUNT_B.address,
+        chainId: 1,
+        nonce: 420n,
+      },
+      account: TEST_ACCOUNT_A,
+    });
+
+    expect(signedAuth).toMatchInlineSnapshot(`
+      {
+        "address": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+        "chainId": 1,
+        "nonce": 420n,
+        "r": 102725860776773423628916613503801445158901377966270769628473190730870496434730n,
+        "s": 25812735492740097245003859854864857180049536150520605332837906559451311728806n,
+        "yParity": 0,
+      }
+    `);
+  });
+});
+
+describe("signAuthorizations", () => {
+  it("should sign multiple authorizations", async () => {
+    const authorizations: Authorization[] = [
+      {
+        address: TEST_ACCOUNT_B.address,
+        chainId: 1,
+        nonce: 420n,
+      },
+      {
+        address: TEST_ACCOUNT_C.address,
+        chainId: 1,
+        nonce: 421n,
+      },
+    ];
+
+    const authorizationList = await signAuthorizations({
+      authorizations,
+      account: TEST_ACCOUNT_A,
+    });
+
+    expect(authorizationList).toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+          "chainId": 1,
+          "nonce": 420n,
+          "r": 102725860776773423628916613503801445158901377966270769628473190730870496434730n,
+          "s": 25812735492740097245003859854864857180049536150520605332837906559451311728806n,
+          "yParity": 0,
+        },
+        {
+          "address": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+          "chainId": 1,
+          "nonce": 421n,
+          "r": 108482619199996736781930236539430222748019956875459721295513303884715556878431n,
+          "s": 17328756565811311106451462386592517658555637219672290207851357199682941049520n,
+          "yParity": 0,
+        },
+      ]
+    `);
+  });
+});

packages/thirdweb/src/transaction/actions/eip7702/sign-authorization.ts

@@ -0,0 +1,71 @@
+import * as ox__Authorization from "ox/Authorization";
+import * as ox__Signature from "ox/Signature";
+import type { Account } from "../../../wallets/interfaces/wallet.js";
+import type { Authorization, SignedAuthorization } from "./authorization.js";
+
+/**
+ * Signs a single EIP-7702 authorization using the provided account.
+ *
+ * @param options - The options for signing the authorization.
+ * @param options.authorization - The authorization object to be signed.
+ * @param options.account - The account used to sign the authorization.
+ * @returns A promise that resolves to a `SignedAuthorization` object.
+ *
+ * @example
+ * ```typescript
+ * const signedAuth = await signAuthorization({
+ *   authorization: myAuthorization,
+ *   account: myAccount,
+ * });
+ * ```
+ *
+ * @beta
+ * @transaction
+ */
+export async function signAuthorization(options: {
+  authorization: Authorization;
+  account: Account;
+}): Promise<SignedAuthorization> {
+  const { authorization, account } = options;
+  const hexSignature = await account.signMessage({
+    message: { raw: ox__Authorization.getSignPayload(authorization) },
+  });
+  return ox__Authorization.from(authorization, {
+    signature: ox__Signature.fromHex(hexSignature),
+  });
+}
+
+/**
+ * Signs a list of EIP-7702 authorizations using the provided account.
+ *
+ * @param options - The options for signing the authorizations.
+ * @param options.authorizations - An array of authorization objects to be signed.
+ * @param options.account - The account used to sign the authorizations.
+ * @returns A promise that resolves to an array of `SignedAuthorization` objects.
+ *
+ * @example
+ * ```typescript
+ * const signedAuths = await signAuthorizations({
+ *   authorizations: [auth1, auth2],
+ *   account: myAccount,
+ * });
+ * ```
+ *
+ * @beta
+ * @transaction
+ */
+export async function signAuthorizations(options: {
+  authorizations: Authorization[];
+  account: Account;
+}): Promise<SignedAuthorization[]> {
+  const { authorizations, account } = options;
+
+  return Promise.all(
+    authorizations.map(async (authorization: Authorization) =>
+      signAuthorization({
+        authorization,
+        account,
+      }),
+    ),
+  );
+}

packages/thirdweb/src/transaction/actions/send-transaction.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it, vi } from "vitest";
+import { wagmiTokenContractConfig } from "../../../test/src/abis/wagmiToken.js";
 import { TEST_WALLET_B } from "../../../test/src/addresses.js";
 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 type { Address } from "../../utils/address.js";
 import { prepareTransaction } from "../prepare-transaction.js";
 import * as TransactionStore from "../transaction-store.js";
 import { sendTransaction } from "./send-transaction.js";
@@ -28,6 +30,33 @@ describe("sendTransaction", () => {
     expect(res.transactionHash.length).toBe(66);
   });
 
+  it("should send an eip7702 transaction", async () => {
+    const transaction = prepareTransaction({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      value: 100n,
+      to: TEST_WALLET_B,
+      authorizations: [
+        {
+          address: wagmiTokenContractConfig.address.toLowerCase() as Address,
+          chainId: 1,
+          nonce: 420n,
+        },
+        {
+          address: "0x0000000000000000000000000000000000000000",
+          chainId: 10,
+          nonce: 69n,
+        },
+      ],
+    });
+    const res = await sendTransaction({
+      account: TEST_ACCOUNT_A,
+      transaction,
+    });
+
+    expect(res.transactionHash.length).toBe(66);
+  });
+
   it("should add transaction to session", async () => {
     const transaction = prepareTransaction({
       chain: ANVIL_CHAIN,

packages/thirdweb/src/transaction/actions/send-transaction.ts

@@ -110,6 +110,32 @@ export interface SendTransactionOptions {
  * });
  * ```
  *
+ * ### Send an EIP-7702 Transaction
+ *
+ * **Note: This feature is in beta and is subject to breaking changes**
+ *
+ * ```ts
+ * import { sendTransaction, prepareTransaction } from "thirdweb";
+ * import { sepolia } from "thirdweb/chains";
+ *
+ * const transaction = prepareTransaction({
+ *   chain: sepolia,
+ *   client: client,
+ *   authorizations: [
+ *     {
+ *       address: "0x...",
+ *       chainId: 1,
+ *       nonce: 420n,
+ *     },
+ *   ],
+ * });
+ *
+ * const { transactionHash } = await sendTransaction({
+ *  account,
+ *  transaction,
+ * });
+ * ```
+ *
  * ### Gasless usage with [thirdweb Engine](https://portal.thirdweb.com/engine)
  * ```ts
  * const { transactionHash } = await sendTransaction({
@@ -166,7 +192,7 @@ export async function sendTransaction(
 
   const serializableTransaction = await toSerializableTransaction({
     transaction: transaction,
-    from: account.address,
+    from: account,
   });
 
   // branch for gasless transactions