thirdweb 5.74.0 → 5.75.0

package/src/wallets/private-key.ts

@@ -1,19 +1,16 @@
 import { secp256k1 } from "@noble/curves/secp256k1";
-import type {
-  SignableMessage,
-  TransactionSerializable,
-  TypedData,
-  TypedDataDefinition,
-} from "viem";
+import type * as ox__TypedData from "ox/TypedData";
 import { publicKeyToAddress } from "viem/utils";
 import { getCachedChain } from "../chains/utils.js";
 import type { ThirdwebClient } from "../client/client.js";
 import { eth_sendRawTransaction } from "../rpc/actions/eth_sendRawTransaction.js";
 import { getRpcClient } from "../rpc/rpc.js";
 import { signTransaction } from "../transaction/actions/sign-transaction.js";
+import type { SerializableTransaction } from "../transaction/serialize-transaction.js";
 import { type Hex, toHex } from "../utils/encoding/hex.js";
 import { signMessage } from "../utils/signatures/sign-message.js";
 import { signTypedData } from "../utils/signatures/sign-typed-data.js";
+import type { Prettify } from "../utils/type-utils.js";
 import type { Account } from "./interfaces/wallet.js";
 
 export type PrivateKeyToAccountOptions = {
@@ -46,6 +43,13 @@ export type PrivateKeyToAccountOptions = {
   privateKey: string;
 };
 
+type Message = Prettify<
+  | string
+  | {
+      raw: Hex | Uint8Array;
+    }
+>;
+
 /**
  * Get an `Account` object from a private key.
  * @param options - The options for `privateKeyToAccount`
@@ -69,14 +73,12 @@ export function privateKeyToAccount(
   const privateKey = `0x${options.privateKey.replace(/^0x/, "")}` satisfies Hex;
 
   const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
-  const address = publicKeyToAddress(publicKey); // TODO: Implement publicKeyToAddress natively (will need checksumAddress downstream)
+  const address = publicKeyToAddress(publicKey);
 
   const account = {
     address,
     sendTransaction: async (
-      // TODO: figure out how we would pass our "chain" object in here?
-      // maybe we *do* actually have to take in a tx object instead of the raw tx?
-      tx: TransactionSerializable & { chainId: number },
+      tx: SerializableTransaction & { chainId: number },
     ) => {
       const rpcRequest = getRpcClient({
         client: client,
@@ -94,24 +96,24 @@ export function privateKeyToAccount(
         transactionHash,
       };
     },
-    signMessage: async ({ message }: { message: SignableMessage }) => {
+    signMessage: async ({ message }: { message: Message }) => {
       return signMessage({
         message,
         privateKey,
       });
     },
     signTypedData: async <
-      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>,
     ) => {
       return signTypedData({
         ..._typedData,
         privateKey,
       });
     },
-    signTransaction: async (tx: TransactionSerializable) => {
+    signTransaction: async (tx: SerializableTransaction) => {
       return signTransaction({
         transaction: tx,
         privateKey,

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";
@@ -23,17 +16,14 @@ import { readContract } from "../../transaction/read-contract.js";
 import { getAddress } from "../../utils/address.js";
 import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.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,
@@ -94,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;
 
@@ -156,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,
@@ -279,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,
+      if (options.overrides?.signMessage) {
+        return options.overrides.signMessage({
+          adminAccount: options.personalAccount,
+          factoryContract: options.factoryContract,
           accountContract,
+          message,
         });
-        // 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({
-          accountContract,
-        });
-      }
-
-      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);
@@ -574,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);
     },
@@ -589,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;
@@ -659,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";
@@ -86,7 +87,7 @@ export async function estimateUserOpGas(
     params: [
       hexlifyUserOp(args.userOp),
       args.options.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
-      stateOverrides,
+      stateOverrides ?? {},
     ],
   });
 
@@ -227,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,
@@ -243,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/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();