thirdweb 5.34.0-nightly-f6ff5a78fc2d65f0f250b154f1405210ca57ce0a-20240708000345 → 5.34.0-nightly-95c9d3d92406de619cb1e4cccc61b0766dd2a0d4-20240708205331

package/src/utils/hashing/hashTypedData.ts

@@ -0,0 +1,210 @@
+import {
+  type AbiParameter,
+  type TypedData,
+  type TypedDataDefinition,
+  concat,
+  getTypesForEIP712Domain,
+  hashDomain,
+  validateTypedData,
+} from "viem";
+import { encodeAbiParameters } from "../abi/encodeAbiParameters.js";
+import { type Hex, toHex } from "../encoding/hex.js";
+import { keccak256 } from "./keccak256.js";
+
+type MessageTypeProperty = {
+  name: string;
+  type: string;
+};
+
+export type HashTypedDataParams<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+> = TypedDataDefinition<typedData, primaryType>;
+
+/**
+ * @internal
+ */
+export function hashTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | "EIP712Domain",
+>(parameters: HashTypedDataParams<typedData, primaryType>): Hex {
+  const {
+    domain = {},
+    message,
+    primaryType,
+  } = parameters as HashTypedDataParams;
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...parameters.types,
+  };
+
+  // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
+  // as we can't statically check this with TypeScript.
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types,
+  });
+
+  const parts: Hex[] = ["0x1901"];
+  if (domain)
+    parts.push(
+      hashDomain({
+        domain,
+        types: types as Record<string, MessageTypeProperty[]>,
+      }),
+    );
+
+  if (primaryType !== "EIP712Domain") {
+    const hashedStruct = (() => {
+      const encoded = encodeData({
+        data: message,
+        primaryType,
+        types: types as Record<string, MessageTypeProperty[]>,
+      });
+      return keccak256(encoded);
+    })();
+
+    parts.push(hashedStruct);
+  }
+
+  return keccak256(concat(parts));
+}
+
+function encodeData({
+  data,
+  primaryType,
+  types,
+}: {
+  data: Record<string, unknown>;
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  const encodedTypes: AbiParameter[] = [{ type: "bytes32" }];
+  const encodedValues: unknown[] = [hashType({ primaryType, types })];
+
+  if (!types[primaryType]) throw new Error("Invalid types");
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name],
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+
+function hashType({
+  primaryType,
+  types,
+}: {
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+
+export function encodeType({
+  primaryType,
+  types,
+}: {
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    if (!types[type]) throw new Error("Invalid types");
+    result += `${type}(${types[type]
+      .map(({ name, type: t }) => `${t} ${name}`)
+      .join(",")})`;
+  }
+
+  return result;
+}
+
+function findTypeDependencies(
+  {
+    primaryType: primaryType_,
+    types,
+  }: {
+    primaryType: string;
+    types: Record<string, MessageTypeProperty[]>;
+  },
+  results: Set<string> = new Set(),
+): Set<string> {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0] as string;
+  if (results.has(primaryType) || types[primaryType] === undefined) {
+    return results;
+  }
+
+  results.add(primaryType);
+
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+
+function encodeField({
+  types,
+  name,
+  type,
+  value,
+}: {
+  types: Record<string, MessageTypeProperty[]>;
+  name: string;
+  type: string;
+  // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+  value: any;
+  // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+}): [type: AbiParameter, value: any] {
+  if (types[type] !== undefined) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types })),
+    ];
+  }
+
+  if (type === "bytes") {
+    const prepend = value.length % 2 ? "0" : "";
+    value = `0x${prepend + value.slice(2)}`;
+    return [{ type: "bytes32" }, keccak256(value)];
+  }
+
+  if (type === "string") return [{ type: "bytes32" }, keccak256(toHex(value))];
+
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+    const typeValuePairs = (value as [AbiParameter, any][]).map((item) =>
+      encodeField({
+        name,
+        type: parsedType,
+        types,
+        value: item,
+      }),
+    );
+    return [
+      { type: "bytes32" },
+      keccak256(
+        encodeAbiParameters(
+          typeValuePairs.map(([t]) => t),
+          typeValuePairs.map(([, v]) => v),
+        ),
+      ),
+    ];
+  }
+
+  return [{ type }, value];
+}

package/src/utils/jwt/decode-jwt.ts

@@ -15,7 +15,7 @@ import type { JWTPayload } from "./types.js";
  * const { payload, signature } = decodeJWT(jwt);
  * ```
  */
-export function deccodeJWT(jwt: string) {
+export function decodeJWT(jwt: string) {
   const [encodedHeader, encodedPayload, encodedSignature] = jwt.split(".");
 
   if (encodedHeader !== PRECOMPILED_B64_ENCODED_JWT_HEADER) {

package/src/utils/jwt/refresh-jwt.ts

@@ -1,5 +1,5 @@
 import type { Account } from "../../wallets/interfaces/wallet.js";
-import { deccodeJWT } from "./decode-jwt.js";
+import { decodeJWT } from "./decode-jwt.js";
 import { encodeJWT } from "./encode-jwt.js";
 
 const DEFAULT_EXPIRATION_TIME = 60 * 60 * 24;
@@ -27,7 +27,7 @@ export type RefreshJWTParams = {
  */
 export async function refreshJWT(options: RefreshJWTParams): Promise<string> {
   const { account, jwt, expirationTime = DEFAULT_EXPIRATION_TIME } = options;
-  const payload = deccodeJWT(jwt).payload;
+  const payload = decodeJWT(jwt).payload;
   return encodeJWT({
     payload: {
       iss: payload.iss,

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.34.0-nightly-f6ff5a78fc2d65f0f250b154f1405210ca57ce0a-20240708000345";
+export const version = "5.34.0-nightly-95c9d3d92406de619cb1e4cccc61b0766dd2a0d4-20240708205331";

package/src/wallets/smart/index.ts

@@ -110,9 +110,11 @@ export async function connectSmartWallet(
   });
 
   // TODO: listen for chainChanged event on the personal wallet and emit the disconnect event on the smart wallet
-  const accountAddress = await predictAddress(factoryContract, {
-    personalAccountAddress: personalAccount.address,
-    ...options,
+  const accountAddress = await predictAddress({
+    factoryContract,
+    adminAddress: personalAccount.address,
+    predictAddressOverride: options.overrides?.predictAddress,
+    accountSalt: options.overrides?.accountSalt,
   })
     .then((address) => address)
     .catch((err) => {
@@ -168,8 +170,8 @@ async function createSmartAccount(
     async sendTransaction(transaction: SendTransactionOption) {
       const executeTx = prepareExecute({
         accountContract,
-        options,
         transaction,
+        executeOverride: options.overrides?.execute,
       });
       return _sendUserOp({
         executeTx,
@@ -179,8 +181,8 @@ async function createSmartAccount(
     async sendBatchTransaction(transactions: SendTransactionOption[]) {
       const executeTx = prepareBatchExecute({
         accountContract,
-        options,
         transactions,
+        executeBatchOverride: options.overrides?.executeBatch,
       });
       return _sendUserOp({
         executeTx,
@@ -387,8 +389,9 @@ function createZkSyncAccount(args: {
         const pmData = await getZkPaymasterData({
           options: {
             client: connectionOptions.client,
-            overrides: creationOptions.overrides,
             chain,
+            bundlerUrl: creationOptions.overrides?.bundlerUrl,
+            entrypointAddress: creationOptions.overrides?.entrypointAddress,
           },
           transaction: serializableTransaction,
         });
@@ -409,8 +412,9 @@ function createZkSyncAccount(args: {
       const txHash = await broadcastZkTransaction({
         options: {
           client: connectionOptions.client,
-          overrides: creationOptions.overrides,
           chain,
+          bundlerUrl: creationOptions.overrides?.bundlerUrl,
+          entrypointAddress: creationOptions.overrides?.entrypointAddress,
         },
         transaction: serializableTransaction,
         signedTransaction,
@@ -471,10 +475,16 @@ async function _sendUserOp(args: {
   const { executeTx, options } = args;
   const unsignedUserOp = await createUnsignedUserOp({
     transaction: executeTx,
-    options,
+    factoryContract: options.factoryContract,
+    accountContract: options.accountContract,
+    adminAddress: options.personalAccount.address,
+    sponsorGas: options.sponsorGas,
+    overrides: options.overrides,
   });
   const signedUserOp = await signUserOp({
-    options,
+    chain: options.chain,
+    adminAccount: options.personalAccount,
+    entrypointAddress: options.overrides?.entrypointAddress,
     userOp: unsignedUserOp,
   });
   const userOpHash = await bundleUserOp({

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

@@ -21,7 +21,19 @@ import {
 import { hexlifyUserOp } from "./utils.js";
 
 /**
- * @internal
+ * Bundle a user operation.
+ * @param args - The options for bundling a user operation.
+ * @returns The bundle hash of the user operation.
+ * @example
+ * ```ts
+ * import { bundleUserOp } from "thirdweb/wallets/smart";
+ *
+ * const userOpHash = await bundleUserOp({
+ *  userOp,
+ *  options,
+ * });
+ * ```
+ * @walletUtils
  */
 export async function bundleUserOp(args: {
   userOp: UserOperation;
@@ -32,13 +44,25 @@ export async function bundleUserOp(args: {
     operation: "eth_sendUserOperation",
     params: [
       hexlifyUserOp(args.userOp),
-      args.options.overrides?.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
+      args.options.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
     ],
   });
 }
 
 /**
- * @internal
+ * Estimate the gas cost of a user operation.
+ * @param args - The options for estimating the gas cost of a user operation.
+ * @returns The estimated gas cost of the user operation.
+ * @example
+ * ```ts
+ * import { estimateUserOpGas } from "thirdweb/wallets/smart";
+ *
+ * const gasCost = await estimateUserOpGas({
+ *  userOp,
+ *  options,
+ * });
+ * ```
+ * @walletUtils
  */
 export async function estimateUserOpGas(args: {
   userOp: UserOperation;
@@ -49,7 +73,7 @@ export async function estimateUserOpGas(args: {
     operation: "eth_estimateUserOperationGas",
     params: [
       hexlifyUserOp(args.userOp),
-      args.options.overrides?.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
+      args.options.entrypointAddress ?? ENTRYPOINT_ADDRESS_v0_6,
     ],
   });
 
@@ -63,9 +87,20 @@ export async function estimateUserOpGas(args: {
 }
 
 /**
- * @internal
+ * Get the gas fees of a user operation.
+ * @param args - The options for getting the gas price of a user operation.
+ * @returns The gas price of the user operation.
+ * @example
+ * ```ts
+ * import { getUserOpGasPrice } from "thirdweb/wallets/smart";
+ *
+ * const fees = await getUserOpGasPrice({
+ *  options,
+ * });
+ * ```
+ * @walletUtils
  */
-export async function getUserOpGasPrice(args: {
+export async function getUserOpGasFees(args: {
   options: BundlerOptions;
 }): Promise<GasPriceResult> {
   const res = await sendBundlerRequest({
@@ -81,7 +116,20 @@ export async function getUserOpGasPrice(args: {
 }
 
 /**
- * @internal
+ * Get the receipt of a user operation.
+ * @param args - The options for getting the receipt of a user operation.
+ * @returns The receipt of the user operation.
+ * @example
+ * ```ts
+ * import { getUserOpReceipt } from "thirdweb/wallets/smart";
+ *
+ * const receipt = await getUserOpReceipt({
+ *  client,
+ *  chain,
+ *  userOpHash,
+ * });
+ * ```
+ * @walletUtils
  */
 export async function getUserOpReceipt(
   args: BundlerOptions & {
@@ -176,8 +224,7 @@ async function sendBundlerRequest(args: {
     console.debug(`>>> sending ${operation} with payload:`, params);
   }
 
-  const bundlerUrl =
-    options.overrides?.bundlerUrl ?? getDefaultBundlerUrl(options.chain);
+  const bundlerUrl = options.bundlerUrl ?? getDefaultBundlerUrl(options.chain);
   const fetchWithHeaders = getClientFetch(options.client);
   const response = await fetchWithHeaders(bundlerUrl, {
     method: "POST",

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);