thirdweb 5.105.41 → 5.105.42-nightly-2d76cf904079cc74809f571b67ac746fad7aa04f-20250909000351

package/src/extensions/erc7702/__generated__/MinimalAccount/write/createSessionWithSig.ts

@@ -81,134 +81,134 @@ export type CreateSessionWithSigParams = WithOverrides<{
 export const FN_SELECTOR = "0xb5051648" as const;
 const FN_INPUTS = [
   {
+    type: "tuple",
+    name: "sessionSpec",
     components: [
       {
-        name: "signer",
         type: "address",
+        name: "signer",
       },
       {
-        name: "isWildcard",
         type: "bool",
+        name: "isWildcard",
       },
       {
-        name: "expiresAt",
         type: "uint256",
+        name: "expiresAt",
       },
       {
+        type: "tuple[]",
+        name: "callPolicies",
         components: [
           {
-            name: "target",
             type: "address",
+            name: "target",
           },
           {
-            name: "selector",
             type: "bytes4",
+            name: "selector",
           },
           {
-            name: "maxValuePerUse",
             type: "uint256",
+            name: "maxValuePerUse",
           },
           {
+            type: "tuple",
+            name: "valueLimit",
             components: [
               {
-                name: "limitType",
                 type: "uint8",
+                name: "limitType",
               },
               {
-                name: "limit",
                 type: "uint256",
+                name: "limit",
               },
               {
-                name: "period",
                 type: "uint256",
+                name: "period",
               },
             ],
-            name: "valueLimit",
-            type: "tuple",
           },
           {
+            type: "tuple[]",
+            name: "constraints",
             components: [
               {
-                name: "condition",
                 type: "uint8",
+                name: "condition",
               },
               {
-                name: "index",
                 type: "uint64",
+                name: "index",
               },
               {
-                name: "refValue",
                 type: "bytes32",
+                name: "refValue",
               },
               {
+                type: "tuple",
+                name: "limit",
                 components: [
                   {
-                    name: "limitType",
                     type: "uint8",
+                    name: "limitType",
                   },
                   {
-                    name: "limit",
                     type: "uint256",
+                    name: "limit",
                   },
                   {
-                    name: "period",
                     type: "uint256",
+                    name: "period",
                   },
                 ],
-                name: "limit",
-                type: "tuple",
               },
             ],
-            name: "constraints",
-            type: "tuple[]",
           },
         ],
-        name: "callPolicies",
-        type: "tuple[]",
       },
       {
+        type: "tuple[]",
+        name: "transferPolicies",
         components: [
           {
-            name: "target",
             type: "address",
+            name: "target",
           },
           {
-            name: "maxValuePerUse",
             type: "uint256",
+            name: "maxValuePerUse",
           },
           {
+            type: "tuple",
+            name: "valueLimit",
             components: [
               {
-                name: "limitType",
                 type: "uint8",
+                name: "limitType",
               },
               {
-                name: "limit",
                 type: "uint256",
+                name: "limit",
               },
               {
-                name: "period",
                 type: "uint256",
+                name: "period",
               },
             ],
-            name: "valueLimit",
-            type: "tuple",
           },
         ],
-        name: "transferPolicies",
-        type: "tuple[]",
       },
       {
-        name: "uid",
         type: "bytes32",
+        name: "uid",
       },
     ],
-    name: "sessionSpec",
-    type: "tuple",
   },
   {
-    name: "signature",
     type: "bytes",
+    name: "signature",
   },
 ] as const;
 const FN_OUTPUTS = [] as const;
@@ -316,23 +316,23 @@ export function createSessionWithSig(
   });
 
   return prepareContractCall({
-    accessList: async () => (await asyncOptions()).overrides?.accessList,
-    authorizationList: async () =>
-      (await asyncOptions()).overrides?.authorizationList,
     contract: options.contract,
-    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
-    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
-    gas: async () => (await asyncOptions()).overrides?.gas,
-    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
-    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
-    maxPriorityFeePerGas: async () =>
-      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
-    nonce: async () => (await asyncOptions()).overrides?.nonce,
     params: async () => {
       const resolvedOptions = await asyncOptions();
       return [resolvedOptions.sessionSpec, resolvedOptions.signature] as const;
     },
     value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    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/erc7702/__generated__/MinimalAccount/write/execute.ts

@@ -26,22 +26,22 @@ export type ExecuteParams = WithOverrides<{
 export const FN_SELECTOR = "0x3f707e6b" as const;
 const FN_INPUTS = [
   {
+    type: "tuple[]",
+    name: "calls",
     components: [
       {
-        name: "target",
         type: "address",
+        name: "target",
       },
       {
-        name: "value",
         type: "uint256",
+        name: "value",
       },
       {
-        name: "data",
         type: "bytes",
+        name: "data",
       },
     ],
-    name: "calls",
-    type: "tuple[]",
   },
 ] as const;
 const FN_OUTPUTS = [] as const;
@@ -137,23 +137,23 @@ export function execute(
   });
 
   return prepareContractCall({
-    accessList: async () => (await asyncOptions()).overrides?.accessList,
-    authorizationList: async () =>
-      (await asyncOptions()).overrides?.authorizationList,
     contract: options.contract,
-    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
-    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
-    gas: async () => (await asyncOptions()).overrides?.gas,
-    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
-    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
-    maxPriorityFeePerGas: async () =>
-      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
-    nonce: async () => (await asyncOptions()).overrides?.nonce,
     params: async () => {
       const resolvedOptions = await asyncOptions();
       return [resolvedOptions.calls] as const;
     },
     value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    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/erc7702/__generated__/MinimalAccount/write/executeWithSig.ts

@@ -34,36 +34,36 @@ export type ExecuteWithSigParams = WithOverrides<{
 export const FN_SELECTOR = "0xba61557d" as const;
 const FN_INPUTS = [
   {
+    type: "tuple",
+    name: "wrappedCalls",
     components: [
       {
+        type: "tuple[]",
+        name: "calls",
         components: [
           {
-            name: "target",
             type: "address",
+            name: "target",
           },
           {
-            name: "value",
             type: "uint256",
+            name: "value",
           },
           {
-            name: "data",
             type: "bytes",
+            name: "data",
           },
         ],
-        name: "calls",
-        type: "tuple[]",
       },
       {
-        name: "uid",
         type: "bytes32",
+        name: "uid",
       },
     ],
-    name: "wrappedCalls",
-    type: "tuple",
   },
   {
-    name: "signature",
     type: "bytes",
+    name: "signature",
   },
 ] as const;
 const FN_OUTPUTS = [] as const;
@@ -167,23 +167,23 @@ export function executeWithSig(
   });
 
   return prepareContractCall({
-    accessList: async () => (await asyncOptions()).overrides?.accessList,
-    authorizationList: async () =>
-      (await asyncOptions()).overrides?.authorizationList,
     contract: options.contract,
-    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
-    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
-    gas: async () => (await asyncOptions()).overrides?.gas,
-    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
-    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
-    maxPriorityFeePerGas: async () =>
-      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
     method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
-    nonce: async () => (await asyncOptions()).overrides?.nonce,
     params: async () => {
       const resolvedOptions = await asyncOptions();
       return [resolvedOptions.wrappedCalls, resolvedOptions.signature] as const;
     },
     value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    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/erc7702/account/sessionkey.test.ts

@@ -75,7 +75,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         events: [sessionCreatedEvent()],
         logs: receipt.logs,
       });
-      expect(logs[0]?.args.signer).toBe(TEST_ACCOUNT_A.address);
+      expect(logs[0]?.args.newSigner).toBe(TEST_ACCOUNT_A.address);
     });
 
     it("should allow adding granular session keys", async () => {
@@ -124,9 +124,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         events: [sessionCreatedEvent()],
         logs: receipt.logs,
       });
-      expect(logs[0]?.args.signer).toBe(TEST_ACCOUNT_A.address);
-      expect(logs[0]?.args.sessionSpec.callPolicies).toHaveLength(1);
-      expect(logs[0]?.args.sessionSpec.transferPolicies).toHaveLength(1);
+      expect(logs[0]?.args.newSigner).toBe(TEST_ACCOUNT_A.address);
     });
   },
 );

package/src/gas/fee-data.ts

@@ -242,7 +242,7 @@ function getGasStationUrl(chainId: 137 | 80002): string {
     case 137:
       return "https://gasstation.polygon.technology/v2";
     case 80002:
-      return "https://gasstation-testnet.polygon.technology/v2";
+      return "https://gasstation.polygon.technology/amoy";
   }
 }
 

package/src/react/web/ui/ConnectWallet/Modal/AllWalletsUI.tsx

@@ -28,7 +28,6 @@ import { WalletEntryButton } from "../WalletEntryButton.js";
 function AllWalletsUI(props: {
   onBack: () => void;
   onSelect: (wallet: Wallet) => void;
-  specifiedWallets: Wallet[];
   size: "compact" | "wide";
   client: ThirdwebClient;
   recommendedWallets: Wallet[] | undefined;
@@ -39,17 +38,11 @@ function AllWalletsUI(props: {
   const setSelectionData = useSetSelectionData();
 
   const walletList = useMemo(() => {
-    return walletInfos
-      .filter((wallet) => {
-        return (
-          props.specifiedWallets.findIndex((x) => x.id === wallet.id) === -1
-        );
-      })
-      .filter(
-        (info) =>
-          info.id !== "inApp" && info.id !== "embedded" && info.id !== "smart",
-      );
-  }, [props.specifiedWallets]);
+    return walletInfos.filter(
+      (info) =>
+        info.id !== "inApp" && info.id !== "embedded" && info.id !== "smart",
+    );
+  }, []);
 
   const fuseInstance = useMemo(() => {
     return new Fuse(walletList, {

package/src/react/web/ui/ConnectWallet/Modal/ConnectModalContent.tsx

@@ -173,7 +173,6 @@ export const ConnectModalContent = (props: {
         onSelect={setScreen}
         recommendedWallets={props.recommendedWallets}
         size={props.size}
-        specifiedWallets={props.wallets}
       />
     </Suspense>
   );

package/src/react/web/wallets/in-app/WalletAuth.tsx

@@ -104,7 +104,6 @@ export function WalletAuth(props: {
             }}
             recommendedWallets={undefined}
             size={props.size}
-            specifiedWallets={[]}
           />
         </Suspense>
       );

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.105.41";
+export const version = "5.105.42-nightly-2d76cf904079cc74809f571b67ac746fad7aa04f-20250909000351";

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

@@ -14,6 +14,9 @@ import type { SignedAuthorization } from "../../../../transaction/actions/eip770
 import { toSerializableTransaction } from "../../../../transaction/actions/to-serializable-transaction.js";
 import type { SendTransactionResult } from "../../../../transaction/types.js";
 import { getAddress } from "../../../../utils/address.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import { stringify } from "../../../../utils/json.js";
+import { withCache } from "../../../../utils/promise/withCache.js";
 import { randomBytesHex } from "../../../../utils/random.js";
 import type {
   Account,
@@ -23,11 +26,140 @@ import {
   executeWithSignature,
   getQueuedTransactionHash,
 } from "../../../smart/lib/bundler.js";
+import { getDefaultBundlerUrl } from "../../../smart/lib/constants.js";
 import type { BundlerOptions } from "../../../smart/types.js";
 
-const MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS =
-  "0xD6999651Fc0964B9c6B444307a0ab20534a66560";
+interface DelegationContractResponse {
+  id: string;
+  jsonrpc: string;
+  result: {
+    delegationContract: string;
+  };
+}
+
+/**
+ * Fetches the delegation contract address from the bundler using the tw_getDelegationContract RPC method
+ * @internal
+ */
+async function getDelegationContractAddress(args: {
+  client: ThirdwebClient;
+  chain: Chain;
+  bundlerUrl?: string;
+}): Promise<string> {
+  const { client, chain, bundlerUrl } = args;
+  const url = bundlerUrl ?? getDefaultBundlerUrl(chain);
+
+  // Create a cache key based on the bundler URL to ensure we cache per chain/bundler
+  const cacheKey = `delegation-contract:${url}`;
+
+  return withCache(
+    async () => {
+      const fetchWithHeaders = getClientFetch(client);
+
+      const response = await fetchWithHeaders(url, {
+        useAuthToken: true,
+        body: stringify({
+          id: 1,
+          jsonrpc: "2.0",
+          method: "tw_getDelegationContract",
+          params: [],
+        }),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch delegation contract: ${response.status} ${response.statusText}`,
+        );
+      }
 
+      const result: DelegationContractResponse = await response.json();
+
+      if ((result as any).error) {
+        throw new Error(
+          `Delegation contract RPC error: ${JSON.stringify((result as any).error)}`,
+        );
+      }
+
+      if (!result.result?.delegationContract) {
+        throw new Error(
+          "Invalid response: missing delegationContract in result",
+        );
+      }
+
+      return result.result.delegationContract;
+    },
+    { cacheKey, cacheTime: 24 * 60 * 60 * 1000 }, // cache for 24 hours
+  );
+}
+
+/**
+ * Creates an EIP-7702 account that enables EOA (Externally Owned Account) delegation
+ * to smart contract functionality. This allows an EOA to delegate its code execution
+ * to a minimal account contract, enabling features like batch transactions and sponsored gas.
+ *
+ * The minimal account leverages EIP-7702 authorization to delegate the EOA's code to a
+ * MinimalAccount contract, allowing the EOA to execute smart contract functions while
+ * maintaining its original address and private key control.
+ *
+ * @param args - Configuration object for creating the minimal account
+ * @param args.client - The thirdweb client instance for blockchain interactions
+ * @param args.adminAccount - The EOA account that will be delegated to the minimal account contract
+ * @param args.sponsorGas - Optional flag to enable sponsored gas transactions via bundler
+ *
+ * @returns An Account object with enhanced capabilities including batch transactions and EIP-5792 support
+ *
+ * @example
+ * ```typescript
+ * import { createThirdwebClient, sendBatchTransaction } from "thirdweb";
+ * import { privateKeyToAccount } from "thirdweb/wallets";
+ * import { create7702MinimalAccount } from "thirdweb/wallets/in-app";
+ * import { sepolia } from "thirdweb/chains";
+ *
+ * // Create a client
+ * const client = createThirdwebClient({
+ *   clientId: "your-client-id"
+ * });
+ *
+ * // Create an EOA account
+ * const adminAccount = privateKeyToAccount({
+ *   client,
+ *   privateKey: "0x..."
+ * });
+ *
+ * // Wrap it with a EIP-7702 account
+ * const minimal7702Account = create7702MinimalAccount({
+ *   client,
+ *   adminAccount,
+ *   sponsorGas: true // Enable sponsored transactions
+ * });
+ *
+ * // Send a batch of transactions
+ * const result = await sendBatchTransaction({
+ *   account: minimal7702Account,
+ *   transactions: [
+ *   {
+ *     to: "0x...",
+ *     data: "0x...",
+ *     value: 0n,
+ *     chainId: sepolia.id
+ *   },
+ *   {
+ *     to: "0x...",
+ *     data: "0x...",
+ *     value: 0n,
+ *     chainId: sepolia.id
+ *   }
+ * ]});
+ *
+ * console.log("Batch transaction hash:", result.transactionHash);
+ * ```
+ *
+ * @wallet
+ */
 export const create7702MinimalAccount = (args: {
   client: ThirdwebClient;
   adminAccount: Account;
@@ -49,7 +181,14 @@ export const create7702MinimalAccount = (args: {
     });
     // check if account has been delegated already
     let authorization: SignedAuthorization | undefined;
-    const isMinimalAccount = await is7702MinimalAccount(eoaContract);
+    const delegationContractAddress = await getDelegationContractAddress({
+      client,
+      chain,
+    });
+    const isMinimalAccount = await is7702MinimalAccount(
+      eoaContract,
+      delegationContractAddress,
+    );
     if (!isMinimalAccount) {
       // if not, sign authorization
       let nonce = firstTx.nonce
@@ -58,12 +197,12 @@ export const create7702MinimalAccount = (args: {
             await getNonce({
               client,
               address: adminAccount.address,
-              chain: getCachedChain(firstTx.chainId),
+              chain,
             }),
           );
       nonce += sponsorGas ? 0n : 1n;
       const auth = await adminAccount.signAuthorization?.({
-        address: MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS,
+        address: getAddress(delegationContractAddress),
         chainId: firstTx.chainId,
         nonce,
       });
@@ -76,7 +215,7 @@ export const create7702MinimalAccount = (args: {
       // send transaction from executor, needs signature
       const wrappedCalls = {
         calls: txs.map((tx) => ({
-          data: tx.data ?? "0x", // will throw if undefined address
+          data: tx.data ?? "0x",
           target: getAddress(tx.to ?? ""),
           value: tx.value ?? 0n,
         })),
@@ -131,7 +270,7 @@ export const create7702MinimalAccount = (args: {
     const executeTx = execute({
       calls: txs.map((tx) => ({
         data: tx.data ?? "0x",
-        target: tx.to ?? "",
+        target: getAddress(tx.to ?? ""),
         value: tx.value ?? 0n,
       })),
       contract: eoaContract,
@@ -228,7 +367,7 @@ async function getNonce(args: {
     "../../../../rpc/actions/eth_getTransactionCount.js"
   ).then(({ eth_getTransactionCount }) =>
     eth_getTransactionCount(rpcRequest, {
-      address,
+      address: getAddress(address),
       blockTag: "pending",
     }),
   );
@@ -238,14 +377,14 @@ async function getNonce(args: {
 async function is7702MinimalAccount(
   // biome-ignore lint/suspicious/noExplicitAny: TODO properly type tw contract
   eoaContract: ThirdwebContract<any>,
+  delegationContractAddress: string,
 ): 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()
+    target.toLowerCase() === delegationContractAddress.toLowerCase()
   );
 }