thirdweb 5.34.0-nightly-325416ea19905901f30e795cbf93cb8a085be02f-20240708203622 → 5.34.0-nightly-3f0291def5ac8b5006a75e8c1212d4f287647d05-20240709000342

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

@@ -4,28 +4,51 @@ import type { PreparedTransaction } from "../../../transaction/prepare-transacti
 import { readContract } from "../../../transaction/read-contract.js";
 import { stringToHex } from "../../../utils/encoding/hex.js";
 import type { SendTransactionOption } from "../../interfaces/wallet.js";
-import type { SmartAccountOptions, SmartWalletOptions } from "../types.ts";
 
 /**
- * @internal
+ * Predict the address of a smart account.
+ * @param args - The options for predicting the address of a smart account.
+ * @returns The predicted address of the smart account.
+ * @example
+ * ```ts
+ * import { predictAddress } from "thirdweb/wallets/smart";
+ *
+ * const predictedAddress = await predictAddress({
+ *  factoryContract,
+ *  adminAddress,
+ *  accountSalt,
+ * });
+ * ```
+ * @walletUtils
  */
-export async function predictAddress(
-  factoryContract: ThirdwebContract,
-  options: SmartWalletOptions & { personalAccountAddress?: string },
-): Promise<string> {
-  if (options.overrides?.predictAddress) {
-    return options.overrides.predictAddress(factoryContract);
+export async function predictAddress(args: {
+  factoryContract: ThirdwebContract;
+  predictAddressOverride?: (
+    factoryContract: ThirdwebContract,
+  ) => Promise<string>;
+  adminAddress: string;
+  accountSalt?: string;
+  accountAddress?: string;
+}): Promise<string> {
+  const {
+    factoryContract,
+    predictAddressOverride: predictAddress,
+    adminAddress,
+    accountSalt,
+    accountAddress,
+  } = args;
+  if (predictAddress) {
+    return predictAddress(factoryContract);
   }
-  if (options.overrides?.accountAddress) {
-    return options.overrides.accountAddress;
+  if (accountAddress) {
+    return accountAddress;
   }
-  const adminAddress = options.personalAccountAddress;
   if (!adminAddress) {
     throw new Error(
       "Account address is required to predict the smart wallet address.",
     );
   }
-  const extraData = stringToHex(options.overrides?.accountSalt ?? "");
+  const extraData = stringToHex(accountSalt ?? "");
   return readContract({
     contract: factoryContract,
     method: "function getAddress(address, bytes) returns (address)",
@@ -38,19 +61,25 @@ export async function predictAddress(
  */
 export function prepareCreateAccount(args: {
   factoryContract: ThirdwebContract;
-  options: SmartAccountOptions;
+  adminAddress: string;
+  accountSalt?: string;
+  createAccountOverride?: (
+    factoryContract: ThirdwebContract,
+  ) => PreparedTransaction;
 }): PreparedTransaction {
-  const { factoryContract, options } = args;
-  if (options.overrides?.createAccount) {
-    return options.overrides.createAccount(factoryContract);
+  const {
+    adminAddress,
+    factoryContract,
+    createAccountOverride: createAccount,
+    accountSalt,
+  } = args;
+  if (createAccount) {
+    return createAccount(factoryContract);
   }
   return prepareContractCall({
     contract: factoryContract,
     method: "function createAccount(address, bytes) returns (address)",
-    params: [
-      options.personalAccount.address,
-      stringToHex(options.overrides?.accountSalt ?? ""),
-    ],
+    params: [adminAddress, stringToHex(accountSalt ?? "")],
   });
 }
 
@@ -59,12 +88,15 @@ export function prepareCreateAccount(args: {
  */
 export function prepareExecute(args: {
   accountContract: ThirdwebContract;
-  options: SmartAccountOptions;
   transaction: SendTransactionOption;
+  executeOverride?: (
+    accountContract: ThirdwebContract,
+    transaction: SendTransactionOption,
+  ) => PreparedTransaction;
 }): PreparedTransaction {
-  const { accountContract, options, transaction } = args;
-  if (options.overrides?.execute) {
-    return options.overrides.execute(accountContract, transaction);
+  const { accountContract, transaction, executeOverride: execute } = args;
+  if (execute) {
+    return execute(accountContract, transaction);
   }
   return prepareContractCall({
     contract: accountContract,
@@ -82,12 +114,19 @@ export function prepareExecute(args: {
  */
 export function prepareBatchExecute(args: {
   accountContract: ThirdwebContract;
-  options: SmartAccountOptions;
   transactions: SendTransactionOption[];
+  executeBatchOverride?: (
+    accountContract: ThirdwebContract,
+    transactions: SendTransactionOption[],
+  ) => PreparedTransaction;
 }): PreparedTransaction {
-  const { accountContract, options, transactions } = args;
-  if (options.overrides?.executeBatch) {
-    return options.overrides.executeBatch(accountContract, transactions);
+  const {
+    accountContract,
+    transactions,
+    executeBatchOverride: executeBatch,
+  } = args;
+  if (executeBatch) {
+    return executeBatch(accountContract, transactions);
   }
   return prepareContractCall({
     contract: accountContract,

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

@@ -1,10 +1,8 @@
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
 import { hexToBigInt } from "../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../utils/fetch.js";
-import type {
-  PaymasterResult,
-  SmartAccountOptions,
-  UserOperation,
-} from "../types.js";
+import type { PaymasterResult, UserOperation } from "../types.js";
 import {
   DEBUG,
   ENTRYPOINT_ADDRESS_v0_6,
@@ -18,22 +16,23 @@ import { hexlifyUserOp } from "./utils.js";
  */
 export async function getPaymasterAndData(args: {
   userOp: UserOperation;
-  options: SmartAccountOptions;
+  client: ThirdwebClient;
+  chain: Chain;
+  entrypointAddress?: string;
+  paymasterOverride?: (userOp: UserOperation) => Promise<PaymasterResult>;
 }): Promise<PaymasterResult> {
-  const { userOp, options } = args;
+  const { userOp, paymasterOverride, client, chain, entrypointAddress } = args;
 
-  if (options.overrides?.paymaster) {
-    return options.overrides?.paymaster(userOp);
+  if (paymasterOverride) {
+    return paymasterOverride(userOp);
   }
 
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
 
-  const client = options.client;
-  const paymasterUrl = getDefaultPaymasterUrl(options.chain);
-  const entrypoint =
-    options.overrides?.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6;
+  const paymasterUrl = getDefaultPaymasterUrl(chain);
+  const entrypoint = entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6;
 
   // Ask the paymaster to sign the transaction and return a valid paymasterAndData value.
   const fetchWithHeaders = getClientFetch(client);

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

@@ -1,4 +1,6 @@
 import { concat } from "viem";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebContract } from "../../../contract/contract.js";
 import { getDefaultGasOverrides } from "../../../gas/fee-data.js";
 import { encode } from "../../../transaction/actions/encode.js";
 import type { PreparedTransaction } from "../../../transaction/prepare-transaction.js";
@@ -10,14 +12,15 @@ import { hexToBytes } from "../../../utils/encoding/to-bytes.js";
 import { isThirdwebUrl } from "../../../utils/fetch.js";
 import { keccak256 } from "../../../utils/hashing/keccak256.js";
 import { resolvePromisedValue } from "../../../utils/promise/resolve-promised-value.js";
+import type { Account } from "../../interfaces/wallet.js";
 import type {
   BundlerOptions,
-  SmartAccountOptions,
+  SmartWalletOptions,
   UserOperation,
 } from "../types.js";
 import {
   estimateUserOpGas,
-  getUserOpGasPrice,
+  getUserOpGasFees,
   getUserOpReceipt,
 } from "./bundler.js";
 import { prepareCreateAccount } from "./calls.js";
@@ -78,27 +81,53 @@ export async function waitForUserOpReceipt(
  *
  * const userOp = await createUnsignedUserOp({
  *  transaction,
- *  options,
+ *  accountContract,
+ *  sponsorGas,
+ *  overrides,
  * });
  * ```
  * @walletUtils
  */
 export async function createUnsignedUserOp(args: {
   transaction: PreparedTransaction;
-  options: SmartAccountOptions;
+  factoryContract: ThirdwebContract;
+  accountContract: ThirdwebContract;
+  adminAddress: string;
+  sponsorGas: boolean;
+  overrides?: SmartWalletOptions["overrides"];
 }): Promise<UserOperation> {
-  const { transaction: executeTx, options } = args;
-  const isDeployed = await isContractDeployed(options.accountContract);
-  const initCode = isDeployed ? "0x" : await getAccountInitCode(options);
+  const {
+    transaction: executeTx,
+    accountContract,
+    factoryContract,
+    adminAddress,
+    overrides,
+    sponsorGas,
+  } = args;
+  const chain = executeTx.chain;
+  const client = executeTx.client;
+  const isDeployed = await isContractDeployed(accountContract);
+  const initCode = isDeployed
+    ? "0x"
+    : await getAccountInitCode({
+        factoryContract: factoryContract,
+        adminAddress,
+        accountSalt: overrides?.accountSalt,
+        createAccountOverride: overrides?.createAccount,
+      });
   const callData = await encode(executeTx);
+  const bundlerOptions = {
+    client,
+    chain,
+    entrypointAddress: overrides?.entrypointAddress,
+  };
 
   let { maxFeePerGas, maxPriorityFeePerGas } = executeTx;
-  const bundlerUrl =
-    options.overrides?.bundlerUrl ?? getDefaultBundlerUrl(options.chain);
+  const bundlerUrl = overrides?.bundlerUrl ?? getDefaultBundlerUrl(chain);
   if (isThirdwebUrl(bundlerUrl)) {
     // get gas prices from bundler
-    const bundlerGasPrice = await getUserOpGasPrice({
-      options,
+    const bundlerGasPrice = await getUserOpGasFees({
+      options: bundlerOptions,
     });
     maxFeePerGas = bundlerGasPrice.maxFeePerGas;
     maxPriorityFeePerGas = bundlerGasPrice.maxPriorityFeePerGas;
@@ -116,10 +145,7 @@ export async function createUnsignedUserOp(args: {
       maxPriorityFeePerGas = resolvedMaxPriorityFeePerGas;
     } else {
       // Fallback to RPC gas prices if no explicit values provided
-      const feeData = await getDefaultGasOverrides(
-        options.client,
-        options.chain,
-      );
+      const feeData = await getDefaultGasOverrides(client, chain);
 
       // Still check for explicit values in case one is provided and not the other
       maxPriorityFeePerGas =
@@ -132,7 +158,7 @@ export async function createUnsignedUserOp(args: {
   const nonce = randomNonce(); // FIXME getNonce should be overrideable by the wallet
 
   const partialOp: UserOperation = {
-    sender: options.accountContract.address,
+    sender: accountContract.address,
     nonce,
     initCode,
     callData,
@@ -145,10 +171,13 @@ export async function createUnsignedUserOp(args: {
     signature: DUMMY_SIGNATURE,
   };
 
-  if (options.sponsorGas) {
+  if (sponsorGas) {
     const paymasterResult = await getPaymasterAndData({
       userOp: partialOp,
-      options,
+      chain,
+      client,
+      entrypointAddress: overrides?.entrypointAddress,
+      paymasterOverride: overrides?.paymaster,
     });
     const paymasterAndData = paymasterResult.paymasterAndData;
     if (paymasterAndData && paymasterAndData !== "0x") {
@@ -167,7 +196,7 @@ export async function createUnsignedUserOp(args: {
       // otherwise fallback to bundler for gas limits
       const estimates = await estimateUserOpGas({
         userOp: partialOp,
-        options,
+        options: bundlerOptions,
       });
       partialOp.callGasLimit = estimates.callGasLimit;
       partialOp.verificationGasLimit = estimates.verificationGasLimit;
@@ -176,7 +205,10 @@ export async function createUnsignedUserOp(args: {
       if (paymasterAndData && paymasterAndData !== "0x") {
         const paymasterResult2 = await getPaymasterAndData({
           userOp: partialOp,
-          options,
+          chain,
+          client,
+          entrypointAddress: overrides?.entrypointAddress,
+          paymasterOverride: overrides?.paymaster,
         });
         if (
           paymasterResult2.paymasterAndData &&
@@ -190,7 +222,7 @@ export async function createUnsignedUserOp(args: {
     // not gasless, so we just need to estimate gas limits
     const estimates = await estimateUserOpGas({
       userOp: partialOp,
-      options,
+      options: bundlerOptions,
     });
     partialOp.callGasLimit = estimates.callGasLimit;
     partialOp.verificationGasLimit = estimates.verificationGasLimit;
@@ -221,16 +253,18 @@ export async function createUnsignedUserOp(args: {
  */
 export async function signUserOp(args: {
   userOp: UserOperation;
-  options: SmartAccountOptions;
+  chain: Chain;
+  entrypointAddress?: string;
+  adminAccount: Account;
 }): Promise<UserOperation> {
-  const { userOp, options } = args;
+  const { userOp, chain, entrypointAddress, adminAccount } = args;
   const userOpHash = getUserOpHash({
     userOp,
-    entryPoint: options.overrides?.entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
-    chainId: options.chain.id,
+    entryPoint: entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+    chainId: chain.id,
   });
-  if (options.personalAccount.signMessage) {
-    const signature = await options.personalAccount.signMessage({
+  if (adminAccount.signMessage) {
+    const signature = await adminAccount.signMessage({
       message: {
         raw: hexToBytes(userOpHash),
       },
@@ -243,11 +277,21 @@ export async function signUserOp(args: {
   throw new Error("signMessage not implemented in signingAccount");
 }
 
-async function getAccountInitCode(options: SmartAccountOptions): Promise<Hex> {
-  const { factoryContract } = options;
+async function getAccountInitCode(options: {
+  factoryContract: ThirdwebContract;
+  adminAddress: string;
+  accountSalt?: string;
+  createAccountOverride?: (
+    factoryContract: ThirdwebContract,
+  ) => PreparedTransaction;
+}): Promise<Hex> {
+  const { factoryContract, adminAddress, accountSalt, createAccountOverride } =
+    options;
   const deployTx = prepareCreateAccount({
     factoryContract,
-    options,
+    adminAddress,
+    accountSalt,
+    createAccountOverride,
   });
   return concat([factoryContract.address as Hex, await encode(deployTx)]);
 }

package/src/wallets/smart/types.ts

@@ -55,12 +55,12 @@ export type SmartAccountOptions = Prettify<
   }
 >;
 
-export type BundlerOptions = Prettify<
-  Omit<SmartWalletOptions, "chain" | "gasless" | "sponsorGas"> & {
-    chain: Chain;
-    client: ThirdwebClient;
-  }
->;
+export type BundlerOptions = {
+  bundlerUrl?: string;
+  entrypointAddress?: string;
+  chain: Chain;
+  client: ThirdwebClient;
+};
 
 export type SmartWalletConnectionOptions = {
   personalAccount: Account;