thirdweb 5.73.1-nightly-33c23e789e577bd6463e135cec4e25cfcfc9964a-20241205000340 → 5.75.0-nightly-ec84ed37d6db8281d3afb12bc47a20ccc5fe9713-20241207000341

package/src/wallets/smart/index.ts

@@ -1,11 +1,4 @@
-import {
-  type SignableMessage,
-  type TypedData,
-  type TypedDataDefinition,
-  type TypedDataDomain,
-  hashTypedData,
-  maxUint96,
-} from "viem";
+import type * as ox__TypedData from "ox/TypedData";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChain } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
@@ -22,19 +15,15 @@ import type { PreparedTransaction } from "../../transaction/prepare-transaction.
 import { readContract } from "../../transaction/read-contract.js";
 import { getAddress } from "../../utils/address.js";
 import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.js";
-import { concatHex } from "../../utils/encoding/helpers/concat-hex.js";
 import type { Hex } from "../../utils/encoding/hex.js";
-import { parseTypedData } from "../../utils/signatures/helpers/parseTypedData.js";
+import { parseTypedData } from "../../utils/signatures/helpers/parse-typed-data.js";
+import { type SignableMessage, maxUint96 } from "../../utils/types.js";
 import type {
   Account,
   SendTransactionOption,
   Wallet,
 } from "../interfaces/wallet.js";
-import type {
-  CreateWalletArgs,
-  WalletConnectionOption,
-  WalletId,
-} from "../wallet-types.js";
+import type { WalletId } from "../wallet-types.js";
 import {
   broadcastZkTransaction,
   bundleUserOp,
@@ -45,7 +34,12 @@ import {
   prepareBatchExecute,
   prepareExecute,
 } from "./lib/calls.js";
-import { getDefaultAccountFactory } from "./lib/constants.js";
+import {
+  ENTRYPOINT_ADDRESS_v0_6,
+  ENTRYPOINT_ADDRESS_v0_7,
+  getDefaultAccountFactory,
+  getEntryPointVersion,
+} from "./lib/constants.js";
 import {
   clearAccountDeploying,
   createUnsignedUserOp,
@@ -58,6 +52,7 @@ import type {
   SmartAccountOptions,
   SmartWalletConnectionOptions,
   SmartWalletOptions,
+  TokenPaymasterConfig,
   UserOperationV06,
   UserOperationV07,
 } from "./types.js";
@@ -89,8 +84,8 @@ const smartWalletToPersonalAccountMap = new WeakMap<Wallet<"smart">, Account>();
  */
 export async function connectSmartWallet(
   wallet: Wallet<"smart">,
-  connectionOptions: WalletConnectionOption<"smart">,
-  creationOptions: CreateWalletArgs<"smart">[1],
+  connectionOptions: SmartWalletConnectionOptions,
+  creationOptions: SmartWalletOptions,
 ): Promise<[Account, Chain]> {
   const { personalAccount, client, chain: connectChain } = connectionOptions;
 
@@ -116,6 +111,17 @@ export async function connectSmartWallet(
     }
   }
 
+  if (
+    options.overrides?.tokenPaymaster &&
+    !options.overrides?.entrypointAddress
+  ) {
+    // if token paymaster is set, but no entrypoint address, set the entrypoint address to v0.7
+    options.overrides = {
+      ...options.overrides,
+      entrypointAddress: ENTRYPOINT_ADDRESS_v0_7,
+    };
+  }
+
   const factoryAddress =
     options.factoryAddress ??
     getDefaultAccountFactory(options.overrides?.entrypointAddress);
@@ -140,7 +146,6 @@ export async function connectSmartWallet(
     chain: chain,
   });
 
-  // TODO: listen for chainChanged event on the personal wallet and emit the disconnect event on the smart wallet
   const accountAddress = await predictAddress({
     factoryContract,
     adminAddress: personalAccount.address,
@@ -196,12 +201,24 @@ export async function disconnectSmartWallet(
 async function createSmartAccount(
   options: SmartAccountOptions,
 ): Promise<Account> {
+  const erc20Paymaster = options.overrides?.tokenPaymaster;
+  if (erc20Paymaster) {
+    if (
+      getEntryPointVersion(
+        options.overrides?.entrypointAddress || ENTRYPOINT_ADDRESS_v0_6,
+      ) !== "v0.7"
+    ) {
+      throw new Error(
+        "Token paymaster is only supported for entrypoint version v0.7",
+      );
+    }
+  }
+
   const { accountContract } = options;
   const account: Account = {
     address: getAddress(accountContract.address),
     async sendTransaction(transaction: SendTransactionOption) {
       // if erc20 paymaster - check allowance and approve if needed
-      const erc20Paymaster = options.overrides?.erc20Paymaster;
       let paymasterOverride:
         | undefined
         | ((
@@ -215,12 +232,7 @@ async function createSmartAccount(
         });
         const paymasterCallback = async (): Promise<PaymasterResult> => {
           return {
-            paymasterAndData: concatHex([
-              erc20Paymaster.address as Hex,
-              erc20Paymaster?.token as Hex,
-            ]),
-            // for 0.7 compatibility
-            paymaster: erc20Paymaster.address as Hex,
+            paymaster: erc20Paymaster.paymasterAddress as Hex,
             paymasterData: "0x",
           };
         };
@@ -256,175 +268,43 @@ async function createSmartAccount(
       });
     },
     async signMessage({ message }: { message: SignableMessage }) {
-      const [
-        { isContractDeployed },
-        { readContract },
-        { encodeAbiParameters },
-        { hashMessage },
-        { checkContractWalletSignature },
-      ] = await Promise.all([
-        import("../../utils/bytecode/is-contract-deployed.js"),
-        import("../../transaction/read-contract.js"),
-        import("../../utils/abi/encodeAbiParameters.js"),
-        import("../../utils/hashing/hashMessage.js"),
-        import("../../extensions/erc1271/checkContractWalletSignature.js"),
-      ]);
-      const isDeployed = await isContractDeployed(accountContract);
-      if (!isDeployed) {
-        await _deployAccount({
-          options,
-          account,
-          accountContract,
-        });
-        // the bundler and rpc might not be in sync, so while the bundler has a transaction hash for the deployment,
-        // the rpc might not have it yet, so we wait until the rpc confirms the contract is deployed
-        await confirmContractDeployment({
+      if (options.overrides?.signMessage) {
+        return options.overrides.signMessage({
+          adminAccount: options.personalAccount,
+          factoryContract: options.factoryContract,
           accountContract,
+          message,
         });
       }
 
-      const originalMsgHash = hashMessage(message);
-      // check if the account contract supports EIP721 domain separator based signing
-      let factorySupports712 = false;
-      try {
-        // this will throw if the contract does not support it (old factories)
-        await readContract({
-          contract: accountContract,
-          method:
-            "function getMessageHash(bytes32 _hash) public view returns (bytes32)",
-          params: [originalMsgHash],
-        });
-        factorySupports712 = true;
-      } catch {
-        // ignore
-      }
-
-      let sig: `0x${string}`;
-      if (factorySupports712) {
-        const wrappedMessageHash = encodeAbiParameters(
-          [{ type: "bytes32" }],
-          [originalMsgHash],
-        );
-        sig = await options.personalAccount.signTypedData({
-          domain: {
-            name: "Account",
-            version: "1",
-            chainId: options.chain.id,
-            verifyingContract: accountContract.address,
-          },
-          primaryType: "AccountMessage",
-          types: { AccountMessage: [{ name: "message", type: "bytes" }] },
-          message: { message: wrappedMessageHash },
-        });
-      } else {
-        sig = await options.personalAccount.signMessage({ message });
-      }
-
-      const isValid = await checkContractWalletSignature({
-        contract: accountContract,
+      const { deployAndSignMessage } = await import("./lib/signing.js");
+      return deployAndSignMessage({
+        accountContract,
+        factoryContract: options.factoryContract,
+        options,
         message,
-        signature: sig,
       });
-
-      if (isValid) {
-        return sig;
-      }
-      throw new Error(
-        "Unable to verify signature on smart account, please make sure the smart account is deployed and the signature is valid.",
-      );
     },
     async signTypedData<
-      const typedData extends TypedData | Record<string, unknown>,
+      const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-    >(_typedData: TypedDataDefinition<typedData, primaryType>) {
-      const typedData = parseTypedData(_typedData);
-      const [
-        { isContractDeployed },
-        { readContract },
-        { encodeAbiParameters },
-        { checkContractWalletSignedTypedData },
-      ] = await Promise.all([
-        import("../../utils/bytecode/is-contract-deployed.js"),
-        import("../../transaction/read-contract.js"),
-        import("../../utils/abi/encodeAbiParameters.js"),
-        import(
-          "../../extensions/erc1271/checkContractWalletSignedTypedData.js"
-        ),
-      ]);
-      const isSelfVerifyingContract =
-        (
-          typedData.domain as TypedDataDomain
-        )?.verifyingContract?.toLowerCase() ===
-        accountContract.address?.toLowerCase();
-
-      if (isSelfVerifyingContract) {
-        // if the contract is self-verifying, we can just sign the message with the EOA (ie. adding a session key)
-        return options.personalAccount.signTypedData(typedData);
-      }
-
-      const isDeployed = await isContractDeployed(accountContract);
-      if (!isDeployed) {
-        await _deployAccount({
-          options,
-          account,
-          accountContract,
-        });
-        // the bundler and rpc might not be in sync, so while the bundler has a transaction hash for the deployment,
-        // the rpc might not have it yet, so we wait until the rpc confirms the contract is deployed
-        await confirmContractDeployment({
+    >(typedData: ox__TypedData.Definition<typedData, primaryType>) {
+      if (options.overrides?.signTypedData) {
+        return options.overrides.signTypedData({
+          adminAccount: options.personalAccount,
+          factoryContract: options.factoryContract,
           accountContract,
+          typedData,
         });
       }
 
-      const originalMsgHash = hashTypedData(typedData);
-      // check if the account contract supports EIP721 domain separator based signing
-      let factorySupports712 = false;
-      try {
-        // this will throw if the contract does not support it (old factories)
-        await readContract({
-          contract: accountContract,
-          method:
-            "function getMessageHash(bytes32 _hash) public view returns (bytes32)",
-          params: [originalMsgHash],
-        });
-        factorySupports712 = true;
-      } catch {
-        // ignore
-      }
-
-      let sig: `0x${string}`;
-      if (factorySupports712) {
-        const wrappedMessageHash = encodeAbiParameters(
-          [{ type: "bytes32" }],
-          [originalMsgHash],
-        );
-        sig = await options.personalAccount.signTypedData({
-          domain: {
-            name: "Account",
-            version: "1",
-            chainId: options.chain.id,
-            verifyingContract: accountContract.address,
-          },
-          primaryType: "AccountMessage",
-          types: { AccountMessage: [{ name: "message", type: "bytes" }] },
-          message: { message: wrappedMessageHash },
-        });
-      } else {
-        sig = await options.personalAccount.signTypedData(typedData);
-      }
-
-      const isValid = await checkContractWalletSignedTypedData({
-        contract: accountContract,
-        data: typedData,
-        signature: sig,
+      const { deployAndSignTypedData } = await import("./lib/signing.js");
+      return deployAndSignTypedData({
+        accountContract,
+        factoryContract: options.factoryContract,
+        options,
+        typedData,
       });
-
-      if (isValid) {
-        return sig;
-      }
-      throw new Error(
-        "Unable to verify signature on smart account, please make sure the smart account is deployed and the signature is valid.",
-      );
     },
     async onTransactionRequested(transaction) {
       return options.personalAccount.onTransactionRequested?.(transaction);
@@ -436,13 +316,10 @@ async function createSmartAccount(
 async function approveERC20(args: {
   accountContract: ThirdwebContract;
   options: SmartAccountOptions;
-  erc20Paymaster: {
-    address: string;
-    token: string;
-  };
+  erc20Paymaster: TokenPaymasterConfig;
 }) {
   const { accountContract, erc20Paymaster, options } = args;
-  const tokenAddress = erc20Paymaster.token;
+  const tokenAddress = erc20Paymaster.tokenAddress;
   const tokenContract = getContract({
     address: tokenAddress,
     chain: accountContract.chain,
@@ -451,7 +328,7 @@ async function approveERC20(args: {
   const accountAllowance = await allowance({
     contract: tokenContract,
     owner: accountContract.address,
-    spender: erc20Paymaster.address,
+    spender: erc20Paymaster.paymasterAddress,
   });
 
   if (accountAllowance > 0n) {
@@ -460,7 +337,7 @@ async function approveERC20(args: {
 
   const approveTx = approve({
     contract: tokenContract,
-    spender: erc20Paymaster.address,
+    spender: erc20Paymaster.paymasterAddress,
     amountWei: maxUint96 - 1n,
   });
   const transaction = await toSerializableTransaction({
@@ -478,7 +355,7 @@ async function approveERC20(args: {
       ...options,
       overrides: {
         ...options.overrides,
-        erc20Paymaster: undefined,
+        tokenPaymaster: undefined,
       },
     },
   });
@@ -554,9 +431,9 @@ function createZkSyncAccount(args: {
       return connectionOptions.personalAccount.signMessage({ message });
     },
     async signTypedData<
-      const typedData extends TypedData | Record<string, unknown>,
+      const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-    >(_typedData: TypedDataDefinition<typedData, primaryType>) {
+    >(_typedData: ox__TypedData.Definition<typedData, primaryType>) {
       const typedData = parseTypedData(_typedData);
       return connectionOptions.personalAccount.signTypedData(typedData);
     },
@@ -569,30 +446,6 @@ function createZkSyncAccount(args: {
   return account;
 }
 
-async function _deployAccount(args: {
-  options: SmartAccountOptions;
-  account: Account;
-  accountContract: ThirdwebContract;
-}) {
-  const { options, account, accountContract } = args;
-  const [{ sendTransaction }, { prepareTransaction }] = await Promise.all([
-    import("../../transaction/actions/send-transaction.js"),
-    import("../../transaction/prepare-transaction.js"),
-  ]);
-  const dummyTx = prepareTransaction({
-    client: options.client,
-    chain: options.chain,
-    to: accountContract.address,
-    value: 0n,
-    gas: 50000n, // force gas to avoid simulation error
-  });
-  const deployResult = await sendTransaction({
-    transaction: dummyTx,
-    account,
-  });
-  return deployResult;
-}
-
 async function _sendUserOp(args: {
   executeTx: PreparedTransaction;
   options: SmartAccountOptions;
@@ -639,26 +492,6 @@ async function _sendUserOp(args: {
   };
 }
 
-async function confirmContractDeployment(args: {
-  accountContract: ThirdwebContract;
-}) {
-  const { accountContract } = args;
-  const startTime = Date.now();
-  const timeout = 60000; // wait 1 minute max
-  const { isContractDeployed } = await import(
-    "../../utils/bytecode/is-contract-deployed.js"
-  );
-  let isDeployed = await isContractDeployed(accountContract);
-  while (!isDeployed) {
-    if (Date.now() - startTime > timeout) {
-      throw new Error(
-        "Timeout: Smart account deployment not confirmed after 1 minute",
-      );
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    isDeployed = await isContractDeployed(accountContract);
-  }
-}
 async function getEntrypointFromFactory(
   factoryAddress: string,
   client: ThirdwebClient,

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

@@ -1,7 +1,8 @@
-import { type TransactionSerializable, decodeErrorResult } from "viem";
+import { decodeErrorResult } from "viem";
 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 { SerializableTransaction } from "../../../transaction/serialize-transaction.js";
 import type { TransactionReceipt } from "../../../transaction/types.js";
 import { type Hex, hexToBigInt } from "../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../utils/fetch.js";
@@ -67,16 +68,26 @@ export async function bundleUserOp(args: {
  * ```
  * @walletUtils
  */
-export async function estimateUserOpGas(args: {
-  userOp: UserOperationV06 | UserOperationV07;
-  options: BundlerOptions;
-}): Promise<EstimationResult> {
+export async function estimateUserOpGas(
+  args: {
+    userOp: UserOperationV06 | UserOperationV07;
+    options: BundlerOptions;
+  },
+  stateOverrides?: {
+    [x: string]: {
+      stateDiff: {
+        [x: string]: `0x${string}`;
+      };
+    };
+  },
+): Promise<EstimationResult> {
   const res = await sendBundlerRequest({
     ...args,
     operation: "eth_estimateUserOperationGas",
     params: [
       hexlifyUserOp(args.userOp),
       args.options.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
+      stateOverrides ?? {},
     ],
   });
 
@@ -217,7 +228,7 @@ export async function getUserOpReceiptRaw(
  */
 export async function getZkPaymasterData(args: {
   options: BundlerOptions;
-  transaction: TransactionSerializable;
+  transaction: SerializableTransaction;
 }): Promise<PmTransactionData> {
   const res = await sendBundlerRequest({
     options: args.options,
@@ -233,7 +244,7 @@ export async function getZkPaymasterData(args: {
 
 export async function broadcastZkTransaction(args: {
   options: BundlerOptions;
-  transaction: TransactionSerializable;
+  transaction: SerializableTransaction;
   signedTransaction: Hex;
 }): Promise<{ transactionHash: Hex }> {
   const res = await sendBundlerRequest({

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

@@ -66,6 +66,7 @@ export async function predictAddress(args: {
   factoryContract: ThirdwebContract;
   predictAddressOverride?: (
     factoryContract: ThirdwebContract,
+    admin: string,
   ) => Promise<string>;
   adminAddress: string;
   accountSalt?: string;
@@ -79,7 +80,7 @@ export async function predictAddress(args: {
     accountAddress,
   } = args;
   if (predictAddress) {
-    return predictAddress(factoryContract);
+    return predictAddress(factoryContract, adminAddress);
   }
   if (accountAddress) {
     return accountAddress;
@@ -109,6 +110,7 @@ export function prepareCreateAccount(args: {
   accountSalt?: string;
   createAccountOverride?: (
     factoryContract: ThirdwebContract,
+    admin: string,
   ) => PreparedTransaction;
 }): PreparedTransaction {
   const {
@@ -118,7 +120,7 @@ export function prepareCreateAccount(args: {
     accountSalt,
   } = args;
   if (createAccount) {
-    return createAccount(factoryContract);
+    return createAccount(factoryContract, adminAddress);
   }
   const saltHex =
     accountSalt && isHex(accountSalt)

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

@@ -1,6 +1,7 @@
 import type { Chain } from "../../../chains/types.js";
 import { getAddress } from "../../../utils/address.js";
 import { getThirdwebDomains } from "../../../utils/domains.js";
+import type { TokenPaymasterConfig } from "../types.js";
 
 export const DUMMY_SIGNATURE =
   "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
@@ -17,6 +18,28 @@ export const ENTRYPOINT_ADDRESS_v0_7 =
 
 export const MANAGED_ACCOUNT_GAS_BUFFER = 50000n;
 
+type PAYMASTERS = "BASE_USDC" | "CELO_CUSD" | "LISK_LSK";
+export const TokenPaymaster: Record<PAYMASTERS, TokenPaymasterConfig> = {
+  BASE_USDC: {
+    chainId: 8453,
+    paymasterAddress: "0x2222f2738BE6bB7aA0Bfe4AEeAf2908172CF5539",
+    tokenAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    balanceStorageSlot: 9n,
+  },
+  CELO_CUSD: {
+    chainId: 42220,
+    paymasterAddress: "0x3feA3c5744D715ff46e91C4e5C9a94426DfF2aF9",
+    tokenAddress: "0x765DE816845861e75A25fCA122bb6898B8B1282a",
+    balanceStorageSlot: 9n,
+  },
+  LISK_LSK: {
+    chainId: 1135,
+    paymasterAddress: "0x9eb8cf7fBa5ed9EeDCC97a0d52254cc0e9B1AC25",
+    tokenAddress: "0xac485391EB2d7D88253a7F1eF18C37f4242D1A24",
+    balanceStorageSlot: 9n,
+  },
+};
+
 /*
  * @internal
  */

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

@@ -51,17 +51,19 @@ export async function getPaymasterAndData(args: {
   const entrypoint = entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6;
   const paymasterUrl = getDefaultBundlerUrl(chain);
 
+  const body = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "pm_sponsorUserOperation",
+    params: [hexlifyUserOp(userOp), entrypoint],
+  };
+
   // Ask the paymaster to sign the transaction and return a valid paymasterAndData value.
   const fetchWithHeaders = getClientFetch(client);
   const response = await fetchWithHeaders(paymasterUrl, {
     method: "POST",
     headers,
-    body: stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "pm_sponsorUserOperation",
-      params: [hexlifyUserOp(userOp), entrypoint],
-    }),
+    body: stringify(body),
   });
   const res = await response.json();