thirdweb 5.97.3 → 5.98.0

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

package/src/wallets/in-app/core/wallet/enclave-wallet.ts

@@ -13,6 +13,7 @@ import type {
   SendTransactionOption,
 } from "../../../interfaces/wallet.js";
 import { getUserStatus } from "../actions/get-enclave-user-status.js";
+import { signAuthorization as signEnclaveAuthorization } from "../actions/sign-authorization.enclave.js";
 import { signMessage as signEnclaveMessage } from "../actions/sign-message.enclave.js";
 import { signTransaction as signEnclaveTransaction } from "../actions/sign-transaction.enclave.js";
 import { signTypedData as signEnclaveTypedData } from "../actions/sign-typed-data.enclave.js";
@@ -138,7 +139,7 @@ export class EnclaveWallet implements IWebWallet {
         client,
         chain: getCachedChain(tx.chainId),
       });
-      const transaction: Record<string, Hex | number | undefined> = {
+      const transaction: Record<string, unknown> = {
         to: tx.to ? getAddress(tx.to) : undefined,
         data: tx.data,
         value: hexlify(tx.value),
@@ -158,7 +159,12 @@ export class EnclaveWallet implements IWebWallet {
         chainId: toHex(tx.chainId),
       };
 
-      if (hexlify(tx.maxFeePerGas)) {
+      if (tx.authorizationList && tx.authorizationList.length > 0) {
+        transaction.type = 4;
+        transaction.authorizationList = tx.authorizationList;
+        transaction.maxFeePerGas = hexlify(tx.maxFeePerGas);
+        transaction.maxPriorityFeePerGas = hexlify(tx.maxPriorityFeePerGas);
+      } else if (hexlify(tx.maxFeePerGas)) {
         transaction.maxFeePerGas = hexlify(tx.maxFeePerGas);
         transaction.maxPriorityFeePerGas = hexlify(tx.maxPriorityFeePerGas);
         transaction.type = 2;
@@ -243,6 +249,21 @@ export class EnclaveWallet implements IWebWallet {
 
         return signature as Hex;
       },
+      async signAuthorization(payload) {
+        const authorization = await signEnclaveAuthorization({
+          client,
+          payload,
+          storage,
+        });
+        return {
+          address: getAddress(authorization.address),
+          chainId: Number.parseInt(authorization.chainId),
+          nonce: BigInt(authorization.nonce),
+          r: BigInt(authorization.r),
+          s: BigInt(authorization.s),
+          yParity: Number.parseInt(authorization.yParity),
+        };
+      },
     };
   }
 }

package/src/wallets/in-app/core/wallet/index.ts

@@ -5,14 +5,25 @@ import {
   type SocialAuthOption,
   socialAuthOptions,
 } from "../../../../wallets/types.js";
+import type {
+  EcosystemWalletConnectionOptions,
+  EcosystemWalletCreationOptions,
+} from "../../../ecosystem/types.js";
 import type { Account, Wallet } from "../../../interfaces/wallet.js";
-import type { EcosystemWalletId, WalletId } from "../../../wallet-types.js";
+import type { SmartWalletOptions } from "../../../smart/types.js";
 import type {
-  CreateWalletArgs,
+  EcosystemWalletId,
   WalletAutoConnectionOption,
-  WalletConnectionOption,
+  WalletId,
 } from "../../../wallet-types.js";
+import type { CreateWalletArgs } from "../../../wallet-types.js";
+import { create7702MinimalAccount } from "../eip7702/minimal-account.js";
 import type { InAppConnector } from "../interfaces/connector.js";
+import type {
+  ExecutionModeOptions,
+  InAppWalletConnectionOptions,
+  InAppWalletCreationOptions,
+} from "./types.js";
 
 /**
  * Checks if the provided wallet is an in-app wallet.
@@ -30,12 +41,8 @@ export function isInAppWallet(
  * @internal
  */
 export async function connectInAppWallet(
-  options:
-    | WalletConnectionOption<"inApp">
-    | WalletConnectionOption<EcosystemWalletId>,
-  createOptions:
-    | CreateWalletArgs<"inApp">[1]
-    | CreateWalletArgs<EcosystemWalletId>[1],
+  options: InAppWalletConnectionOptions | EcosystemWalletConnectionOptions,
+  createOptions: InAppWalletCreationOptions | EcosystemWalletCreationOptions,
   connector: InAppConnector,
 ): Promise<{ account: Account; chain: Chain; adminAccount?: Account }> {
   if (
@@ -60,21 +67,12 @@ export async function connectInAppWallet(
   const authResult = await connector.connect(options);
   const authAccount = authResult.user.account;
 
-  if (
-    createOptions &&
-    "smartAccount" in createOptions &&
-    createOptions?.smartAccount
-  ) {
-    const [account, chain] = await convertToSmartAccount({
-      client: options.client,
-      authAccount,
-      smartAccountOptions: createOptions.smartAccount,
-      chain: options.chain,
-    });
-    return { account, chain, adminAccount: authAccount };
-  }
-
-  return { account: authAccount, chain: options.chain || ethereum } as const;
+  return createInAppAccount({
+    client: options.client,
+    authAccount,
+    createOptions,
+    desiredChain: options.chain,
+  });
 }
 
 /**
@@ -100,21 +98,12 @@ export async function autoConnectInAppWallet(
 
   const authAccount = user.account;
 
-  if (
-    createOptions &&
-    "smartAccount" in createOptions &&
-    createOptions?.smartAccount
-  ) {
-    const [account, chain] = await convertToSmartAccount({
-      client: options.client,
-      authAccount,
-      smartAccountOptions: createOptions.smartAccount,
-      chain: options.chain,
-    });
-    return { account, chain, adminAccount: authAccount };
-  }
-
-  return { account: authAccount, chain: options.chain || ethereum } as const;
+  return createInAppAccount({
+    client: options.client,
+    authAccount,
+    createOptions,
+    desiredChain: options.chain,
+  });
 }
 
 async function convertToSmartAccount(options: {
@@ -144,3 +133,66 @@ async function getAuthenticatedUser(connector: InAppConnector) {
   }
   return undefined;
 }
+
+async function createInAppAccount(options: {
+  client: ThirdwebClient;
+  authAccount: Account;
+  createOptions: InAppWalletCreationOptions | EcosystemWalletCreationOptions;
+  desiredChain?: Chain;
+}) {
+  const { createOptions, authAccount, desiredChain, client } = options;
+  let smartAccountOptions: SmartWalletOptions | undefined;
+  let eip7702: Extract<ExecutionModeOptions, { mode: "EIP7702" }> | undefined;
+  const executionMode =
+    createOptions && "executionMode" in createOptions
+      ? createOptions.executionMode
+      : undefined;
+
+  if (executionMode) {
+    if (executionMode.mode === "EIP4337") {
+      smartAccountOptions = executionMode.smartAccount;
+    } else if (executionMode.mode === "EIP7702") {
+      eip7702 = executionMode;
+    }
+  }
+
+  // backwards compatibility
+  if (
+    createOptions &&
+    "smartAccount" in createOptions &&
+    createOptions?.smartAccount
+  ) {
+    smartAccountOptions = createOptions.smartAccount;
+  }
+
+  if (smartAccountOptions) {
+    const [account, chain] = await convertToSmartAccount({
+      client,
+      authAccount,
+      smartAccountOptions,
+      chain: desiredChain,
+    });
+    return { account, chain, adminAccount: authAccount };
+  }
+
+  if (eip7702) {
+    const chain = desiredChain;
+    if (!chain) {
+      throw new Error(
+        "Chain is required for EIP-7702 execution, pass a chain when connecting the inAppWallet.",
+      );
+    }
+    const account = create7702MinimalAccount({
+      client,
+      adminAccount: authAccount,
+      sponsorGas: eip7702.sponsorGas,
+    });
+    return {
+      account,
+      chain,
+      adminAccount: authAccount,
+    };
+  }
+
+  return { account: authAccount, chain: desiredChain || ethereum } as const;
+}

package/src/wallets/in-app/core/wallet/types.ts

@@ -41,6 +41,25 @@ export type InAppWalletSocialAuth = SocialAuthOption;
 export type InAppWalletOAuth = OAuthOption;
 export type InAppWalletAuth = AuthOption;
 
+export type ExecutionModeOptions =
+  | {
+      mode: "EIP4337";
+      /**
+       * The 4337 smart account options to convert the wallet to a smart account
+       **/
+      smartAccount?: SmartWalletOptions;
+    }
+  | {
+      mode: "EIP7702";
+      /**
+       * Whether to sponsor the gas cost of the wallet
+       */
+      sponsorGas?: boolean;
+    }
+  | {
+      mode: "EOA";
+    };
+
 export type InAppWalletCreationOptions =
   | {
       auth?: {
@@ -84,6 +103,7 @@ export type InAppWalletCreationOptions =
       partnerId?: string;
       /**
        * The smart account options to convert the wallet to a smart account
+       * @deprecated Use `executionMode` instead
        **/
       smartAccount?: SmartWalletOptions;
       /**
@@ -94,5 +114,13 @@ export type InAppWalletCreationOptions =
        * The storage to use for storing wallet state
        */
       storage?: AsyncStorage;
+
+      /**
+       * Defines the execution behavior of the wallet, 3 different modes are supported:
+       * - "EOA": The wallet will execute transactions as a regular EOA
+       * - "EIP4337": The wallet will execute transactions as a 4337 smart account
+       * - "EIP7702": The wallet will execute transactions as a 7702 smart account
+       */
+      executionMode?: ExecutionModeOptions;
     }
   | undefined;

package/src/wallets/in-app/native/in-app.ts

@@ -1,7 +1,7 @@
 import type { ThirdwebClient } from "../../../client/client.js";
 import type { Wallet } from "../../interfaces/wallet.js";
-import type { CreateWalletArgs } from "../../wallet-types.js";
 import { createInAppWallet } from "../core/wallet/in-app-core.js";
+import type { InAppWalletCreationOptions } from "../core/wallet/types.js";
 
 /**
  * Creates an in-app wallet.
@@ -56,7 +56,7 @@ import { createInAppWallet } from "../core/wallet/in-app-core.js";
  * @wallet
  */
 export function inAppWallet(
-  createOptions?: CreateWalletArgs<"inApp">[1],
+  createOptions?: InAppWalletCreationOptions,
 ): Wallet<"inApp"> {
   return createInAppWallet({
     createOptions,

package/src/wallets/in-app/web/in-app.ts

@@ -1,7 +1,7 @@
 import type { ThirdwebClient } from "../../../client/client.js";
 import type { Wallet } from "../../interfaces/wallet.js";
-import type { CreateWalletArgs } from "../../wallet-types.js";
 import { createInAppWallet } from "../core/wallet/in-app-core.js";
+import type { InAppWalletCreationOptions } from "../core/wallet/types.js";
 
 /**
  * Creates an app scoped wallet for users based on various authentication methods. Full list of available authentication methods [here](https://portal.thirdweb.com/connect/wallet/sign-in-methods/configure).
@@ -251,7 +251,7 @@ import { createInAppWallet } from "../core/wallet/in-app-core.js";
  * @wallet
  */
 export function inAppWallet(
-  createOptions?: CreateWalletArgs<"inApp">[1],
+  createOptions?: InAppWalletCreationOptions,
 ): Wallet<"inApp"> {
   return createInAppWallet({
     createOptions,

package/src/wallets/smart/lib/bundler.ts

@@ -4,6 +4,8 @@ import { getContract } from "../../../contract/contract.js";
 import { parseEventLogs } from "../../../event/actions/parse-logs.js";
 import { userOperationRevertReasonEvent } from "../../../extensions/erc4337/__generated__/IEntryPoint/events/UserOperationRevertReason.js";
 import { postOpRevertReasonEvent } from "../../../extensions/erc4337/__generated__/IEntryPoint_v07/events/PostOpRevertReason.js";
+import type { ExecuteWithSigParams } from "../../../extensions/erc7702/__generated__/MinimalAccount/write/executeWithSig.js";
+import type { SignedAuthorization } from "../../../transaction/actions/eip7702/authorization.js";
 import type { PreparedTransaction } from "../../../transaction/prepare-transaction.js";
 import type { SerializableTransaction } from "../../../transaction/serialize-transaction.js";
 import type { TransactionReceipt } from "../../../transaction/types.js";
@@ -338,6 +340,49 @@ export async function getZkPaymasterData(args: {
   };
 }
 
+/**
+ * @internal
+ */
+export async function executeWithSignature(args: {
+  eoaAddress: `0x${string}`;
+  wrappedCalls: ExecuteWithSigParams["wrappedCalls"];
+  signature: `0x${string}`;
+  authorization: SignedAuthorization | undefined;
+  options: BundlerOptions;
+}): Promise<{ transactionId: string }> {
+  const res = await sendBundlerRequest({
+    ...args,
+    operation: "tw_execute",
+    params: [
+      args.eoaAddress,
+      args.wrappedCalls,
+      args.signature,
+      args.authorization,
+    ],
+  });
+
+  return {
+    transactionId: res.queueId,
+  };
+}
+
+/**
+ * @internal
+ */
+export async function getQueuedTransactionHash(args: {
+  transactionId: string;
+  options: BundlerOptions;
+}): Promise<{ transactionHash: Hex }> {
+  const res = await sendBundlerRequest({
+    ...args,
+    operation: "tw_getTransactionHash",
+    params: [args.transactionId],
+  });
+  return {
+    transactionHash: res.transactionHash,
+  };
+}
+
 export async function broadcastZkTransaction(args: {
   options: BundlerOptions;
   transaction: SerializableTransaction;
@@ -367,7 +412,9 @@ async function sendBundlerRequest(args: {
     | "eth_getUserOperationReceipt"
     | "thirdweb_getUserOperationGasPrice"
     | "zk_paymasterData"
-    | "zk_broadcastTransaction";
+    | "zk_broadcastTransaction"
+    | "tw_execute"
+    | "tw_getTransactionHash";
   // biome-ignore lint/suspicious/noExplicitAny: TODO: fix any
   params: any[];
 }) {
@@ -388,7 +435,6 @@ async function sendBundlerRequest(args: {
     }),
   });
   const res = await response.json();
-
   if (!response.ok || res.error) {
     let error = res.error || response.statusText;
     if (typeof error === "object") {