viem 2.17.11 → 2.18.1

package/account-abstraction/accounts/toSmartAccount.ts

@@ -0,0 +1,126 @@
+import type { Abi } from 'abitype'
+
+import { getCode } from '../../actions/public/getCode.js'
+import type { Prettify } from '../../types/utils.js'
+import { getAction } from '../../utils/getAction.js'
+import { createNonceManager } from '../../utils/nonceManager.js'
+import { serializeErc6492Signature } from '../../utils/signature/serializeErc6492Signature.js'
+import type { EntryPointVersion } from '../types/entryPointVersion.js'
+import type { SmartAccount, SmartAccountImplementation } from './types.js'
+
+export type ToSmartAccountParameters<
+  entryPointAbi extends Abi | readonly unknown[] = Abi,
+  entryPointVersion extends EntryPointVersion = EntryPointVersion,
+  extend extends object = object,
+> = SmartAccountImplementation<entryPointAbi, entryPointVersion, extend>
+
+export type ToSmartAccountReturnType<
+  implementation extends
+    SmartAccountImplementation = SmartAccountImplementation,
+> = Prettify<SmartAccount<implementation>>
+
+/**
+ * @description Creates a Smart Account with a provided account implementation.
+ *
+ * @param parameters - {@link ToSmartAccountParameters}
+ * @returns A Smart Account. {@link ToSmartAccountReturnType}
+ */
+export async function toSmartAccount<
+  implementation extends SmartAccountImplementation,
+>(
+  implementation: implementation,
+): Promise<ToSmartAccountReturnType<implementation>> {
+  const { extend, ...rest } = implementation
+
+  let deployed = false
+
+  const address = await implementation.getAddress()
+
+  const nonceKeyManager = createNonceManager({
+    source: {
+      get() {
+        return Date.now()
+      },
+      set() {},
+    },
+  })
+
+  return {
+    ...extend,
+    ...rest,
+    address,
+    async getFactoryArgs() {
+      if ('isDeployed' in this && (await this.isDeployed()))
+        return { factory: undefined, factoryData: undefined }
+      return implementation.getFactoryArgs()
+    },
+    async getNonce(parameters) {
+      const key =
+        parameters?.key ??
+        BigInt(
+          await nonceKeyManager.consume({
+            address,
+            chainId: implementation.client.chain!.id!,
+            client: implementation.client,
+          }),
+        )
+      return await implementation.getNonce({ ...parameters, key })
+    },
+    async isDeployed() {
+      if (deployed) return true
+      const code = await getAction(
+        implementation.client,
+        getCode,
+        'getCode',
+      )({
+        address,
+      })
+      deployed = Boolean(code)
+      return deployed
+    },
+    ...(implementation.sign
+      ? {
+          async sign(parameters) {
+            const [{ factory, factoryData }, signature] = await Promise.all([
+              this.getFactoryArgs(),
+              implementation.sign!(parameters),
+            ])
+            if (factory && factoryData)
+              return serializeErc6492Signature({
+                address: factory,
+                data: factoryData,
+                signature,
+              })
+            return signature
+          },
+        }
+      : {}),
+    async signMessage(parameters) {
+      const [{ factory, factoryData }, signature] = await Promise.all([
+        this.getFactoryArgs(),
+        implementation.signMessage(parameters),
+      ])
+      if (factory && factoryData)
+        return serializeErc6492Signature({
+          address: factory,
+          data: factoryData,
+          signature,
+        })
+      return signature
+    },
+    async signTypedData(parameters) {
+      const [{ factory, factoryData }, signature] = await Promise.all([
+        this.getFactoryArgs(),
+        implementation.signTypedData(parameters),
+      ])
+      if (factory && factoryData)
+        return serializeErc6492Signature({
+          address: factory,
+          data: factoryData,
+          signature,
+        })
+      return signature
+    },
+    type: 'smart',
+  } as ToSmartAccountReturnType<implementation>
+}

package/account-abstraction/accounts/toWebAuthnAccount.ts

@@ -0,0 +1,56 @@
+import { type P256Credential, type SignParameters, sign } from 'webauthn-p256'
+
+import type { ErrorType } from '../../errors/utils.js'
+import { hashMessage } from '../../utils/signature/hashMessage.js'
+import { hashTypedData } from '../../utils/signature/hashTypedData.js'
+import type { WebAuthnAccount } from './types.js'
+
+export type ToWebAuthnAccountParameters = {
+  /**
+   * The WebAuthn P256 credential to use.
+   */
+  credential: {
+    id: P256Credential['id']
+    publicKey: P256Credential['publicKey']
+  }
+  /**
+   * Credential request function. Useful for environments that do not support
+   * the WebAuthn API natively (i.e. React Native or testing environments).
+   *
+   * @default window.navigator.credentials.get
+   */
+  getFn?: SignParameters['getFn'] | undefined
+  /**
+   * The relying party identifier to use.
+   */
+  rpId?: SignParameters['rpId'] | undefined
+}
+
+export type ToWebAuthnAccountReturnType = WebAuthnAccount
+
+export type ToWebAuthnAccountErrorType = ErrorType
+
+/**
+ * @description Creates an Account from a WebAuthn Credential.
+ *
+ * @returns A WebAuthn Account.
+ */
+export function toWebAuthnAccount(
+  parameters: ToWebAuthnAccountParameters,
+): WebAuthnAccount {
+  const { getFn, rpId } = parameters
+  const { id, publicKey } = parameters.credential
+  return {
+    publicKey,
+    async sign({ hash }) {
+      return sign({ credentialId: id, getFn, hash, rpId })
+    },
+    async signMessage({ message }) {
+      return this.sign({ hash: hashMessage(message) })
+    },
+    async signTypedData(parameters) {
+      return this.sign({ hash: hashTypedData(parameters) })
+    },
+    type: 'webAuthn',
+  }
+}

package/account-abstraction/accounts/types.ts

@@ -0,0 +1,208 @@
+import type { Abi, Address, TypedData } from 'abitype'
+import type { SignReturnType as WebAuthnSignReturnType } from 'webauthn-p256'
+
+import type { Client } from '../../clients/createClient.js'
+import type { Hash, Hex, SignableMessage } from '../../types/misc.js'
+import type { TypedDataDefinition } from '../../types/typedData.js'
+import type { Assign, ExactPartial, UnionPartialBy } from '../../types/utils.js'
+import type { EntryPointVersion } from '../types/entryPointVersion.js'
+import type {
+  EstimateUserOperationGasReturnType,
+  UserOperation,
+  UserOperationRequest,
+} from '../types/userOperation.js'
+
+type Call = {
+  to: Hex
+  data?: Hex | undefined
+  value?: bigint | undefined
+}
+
+export type SmartAccountImplementation<
+  entryPointAbi extends Abi | readonly unknown[] = Abi,
+  entryPointVersion extends EntryPointVersion = EntryPointVersion,
+  extend extends object = object,
+> = {
+  /** Client used to retrieve Smart Account data, and perform signing (if owner is a JSON-RPC Account). */
+  client: Client
+  /** Compatible EntryPoint of the Smart Account. */
+  entryPoint: {
+    /** Compatible EntryPoint ABI. */
+    abi: entryPointAbi
+    /** Compatible EntryPoint address. */
+    address: Address
+    /** Compatible EntryPoint version. */
+    version: entryPointVersion
+  }
+  /** Extend the Smart Account with custom properties. */
+  extend?: extend | undefined
+  /**
+   * Retrieves the Smart Account's address.
+   *
+   * @example
+   * ```ts
+   * const address = await account.getAddress()
+   * // '0x...'
+   * ```
+   */
+  getAddress: () => Promise<Address>
+  /**
+   * Encodes the calls into calldata for executing a User Operation.
+   *
+   * @example
+   * ```ts
+   * const callData = await account.encodeCalls([
+   *   { to: '0x...', data: '0x...' },
+   *   { to: '0x...', data: '0x...', value: 100n },
+   * ])
+   * // '0x...'
+   * ```
+   */
+  encodeCalls: (calls: readonly Call[]) => Promise<Hex>
+  /**
+   * Retrieves the calldata for factory call to deploy a Smart Account.
+   * If the Smart Account has already been deployed, this will return undefined values.
+   *
+   * @example Counterfactual account
+   * ```ts
+   * const { factory, factoryData } = await account.getFactoryArgs()
+   * // { factory: '0x...', factoryData: '0x...' }
+   * ```
+   *
+   * @example Deployed account
+   * ```ts
+   * const { factory, factoryData } = await account.getFactoryArgs()
+   * // { factory: undefined, factoryData: undefined }
+   * ```
+   */
+  getFactoryArgs: () => Promise<{
+    factory?: Address | undefined
+    factoryData?: Hex | undefined
+  }>
+  /**
+   * Retrieves the nonce of the Account.
+   *
+   * @example
+   * ```ts
+   * const nonce = await account.getNonce()
+   * // 1n
+   * ```
+   */
+  getNonce: (
+    parameters?: { key?: bigint | undefined } | undefined,
+  ) => Promise<bigint>
+  /**
+   * Retrieves the User Operation "stub" signature for gas estimation.
+   *
+   * ```ts
+   * const signature = await account.getStubSignature()
+   * // '0x...'
+   * ```
+   */
+  getStubSignature: () => Promise<Hex>
+  /**
+   * Signs a hash via the Smart Account's owner.
+   *
+   * @example
+   * ```ts
+   * const signature = await account.sign({
+   *   hash: '0x...'
+   * })
+   * // '0x...'
+   * ```
+   */
+  sign?: ((parameters: { hash: Hash }) => Promise<Hex>) | undefined
+  /**
+   * Signs a [EIP-191 Personal Sign message](https://eips.ethereum.org/EIPS/eip-191).
+   *
+   * @example
+   * ```ts
+   * const signature = await account.signMessage({
+   *   message: 'Hello, World!'
+   * })
+   * // '0x...'
+   * ```
+   */
+  signMessage: (parameters: { message: SignableMessage }) => Promise<Hex>
+  /**
+   * Signs [EIP-712 Typed Data](https://eips.ethereum.org/EIPS/eip-712).
+   *
+   * @example
+   * ```ts
+   * const signature = await account.signTypedData({
+   *   domain,
+   *   types,
+   *   primaryType: 'Mail',
+   *   message,
+   * })
+   * ```
+   */
+  signTypedData: <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  >(
+    parameters: TypedDataDefinition<typedData, primaryType>,
+  ) => Promise<Hex>
+  /**
+   * Signs the User Operation.
+   *
+   * @example
+   * ```ts
+   * const signature = await account.signUserOperation({
+   *   chainId: 1,
+   *   userOperation,
+   * })
+   * ```
+   */
+  signUserOperation: (
+    parameters: UnionPartialBy<UserOperation, 'sender'> & {
+      chainId?: number | undefined
+    },
+  ) => Promise<Hex>
+  /** User Operation configuration properties. */
+  userOperation?:
+    | {
+        /** Prepares gas properties for the User Operation request. */
+        estimateGas?:
+          | ((
+              userOperation: UserOperationRequest,
+            ) => Promise<
+              ExactPartial<EstimateUserOperationGasReturnType> | undefined
+            >)
+          | undefined
+      }
+    | undefined
+}
+
+export type SmartAccount<
+  implementation extends
+    SmartAccountImplementation = SmartAccountImplementation,
+> = Assign<
+  implementation['extend'],
+  Assign<
+    implementation,
+    {
+      /** Address of the Smart Account. */
+      address: Address
+      /** Whether or not the Smart Account has been deployed. */
+      isDeployed: () => Promise<boolean>
+      /** Type of account. */
+      type: 'smart'
+    }
+  >
+>
+
+export type WebAuthnAccount = {
+  publicKey: Hex
+  sign: ({ hash }: { hash: Hash }) => Promise<WebAuthnSignReturnType>
+  signMessage: ({
+    message,
+  }: { message: SignableMessage }) => Promise<WebAuthnSignReturnType>
+  signTypedData: <
+    const typedData extends TypedDataDefinition | Record<string, unknown>,
+    primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  >(
+    typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
+  ) => Promise<WebAuthnSignReturnType>
+  type: 'webAuthn'
+}

package/account-abstraction/actions/bundler/estimateUserOperationGas.ts

@@ -0,0 +1,170 @@
+import type { Address, Narrow } from 'abitype'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../../accounts/utils/parseAccount.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../../errors/account.js'
+import type { BaseError } from '../../../errors/base.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import type { Assign, OneOf, Prettify } from '../../../types/utils.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import { getAction } from '../../../utils/getAction.js'
+import type { SmartAccount } from '../../accounts/types.js'
+import type { PaymasterActions } from '../../clients/decorators/paymaster.js'
+import type {
+  DeriveSmartAccount,
+  GetSmartAccountParameter,
+} from '../../types/account.js'
+import type {
+  DeriveEntryPointVersion,
+  EntryPointVersion,
+} from '../../types/entryPointVersion.js'
+import type {
+  EstimateUserOperationGasReturnType as EstimateUserOperationGasReturnType_,
+  UserOperation,
+  UserOperationCalls,
+  UserOperationRequest,
+} from '../../types/userOperation.js'
+import { getUserOperationError } from '../../utils/errors/getUserOperationError.js'
+import {
+  type FormatUserOperationGasErrorType,
+  formatUserOperationGas,
+} from '../../utils/formatters/userOperationGas.js'
+import {
+  type FormatUserOperationRequestErrorType,
+  formatUserOperationRequest,
+} from '../../utils/formatters/userOperationRequest.js'
+import {
+  type PrepareUserOperationErrorType,
+  type PrepareUserOperationParameters,
+  prepareUserOperation,
+} from './prepareUserOperation.js'
+
+export type EstimateUserOperationGasParameters<
+  account extends SmartAccount | undefined = SmartAccount | undefined,
+  accountOverride extends SmartAccount | undefined = SmartAccount | undefined,
+  calls extends readonly unknown[] = readonly unknown[],
+  //
+  _derivedAccount extends SmartAccount | undefined = DeriveSmartAccount<
+    account,
+    accountOverride
+  >,
+  _derivedVersion extends
+    EntryPointVersion = DeriveEntryPointVersion<_derivedAccount>,
+> = Assign<
+  UserOperationRequest<_derivedVersion>,
+  OneOf<{ calls: UserOperationCalls<Narrow<calls>> } | { callData: Hex }> & {
+    paymaster?:
+      | Address
+      | true
+      | {
+          /** Retrieves paymaster-related User Operation properties to be used for sending the User Operation. */
+          getPaymasterData?: PaymasterActions['getPaymasterData'] | undefined
+          /** Retrieves paymaster-related User Operation properties to be used for gas estimation. */
+          getPaymasterStubData?:
+            | PaymasterActions['getPaymasterStubData']
+            | undefined
+        }
+      | undefined
+    /** Paymaster context to pass to `getPaymasterData` and `getPaymasterStubData` calls. */
+    paymasterContext?: unknown | undefined
+  }
+> &
+  GetSmartAccountParameter<account, accountOverride>
+
+export type EstimateUserOperationGasReturnType<
+  account extends SmartAccount | undefined = SmartAccount | undefined,
+  accountOverride extends SmartAccount | undefined = SmartAccount | undefined,
+  //
+  _derivedAccount extends SmartAccount | undefined = DeriveSmartAccount<
+    account,
+    accountOverride
+  >,
+  _derivedVersion extends
+    EntryPointVersion = DeriveEntryPointVersion<_derivedAccount>,
+> = Prettify<EstimateUserOperationGasReturnType_<_derivedVersion>>
+
+export type EstimateUserOperationGasErrorType =
+  | ParseAccountErrorType
+  | PrepareUserOperationErrorType
+  | FormatUserOperationRequestErrorType
+  | FormatUserOperationGasErrorType
+  | RequestErrorType
+  | ErrorType
+
+/**
+ * Returns an estimate of gas values necessary to execute the User Operation.
+ *
+ * - Docs: https://viem.sh/actions/bundler/estimateUserOperationGas
+ *
+ * @param client - Client to use
+ * @param parameters - {@link EstimateUserOperationGasParameters}
+ * @returns The gas estimate (in wei). {@link EstimateUserOperationGasReturnType}
+ *
+ * @example
+ * import { createBundlerClient, http, parseEther } from 'viem'
+ * import { toSmartAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { estimateUserOperationGas } from 'viem/actions'
+ *
+ * const account = await toSmartAccount({ ... })
+ *
+ * const bundlerClient = createBundlerClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const values = await estimateUserOperationGas(bundlerClient, {
+ *   account,
+ *   calls: [{ to: '0x...', value: parseEther('1') }],
+ * })
+ */
+export async function estimateUserOperationGas<
+  const calls extends readonly unknown[],
+  account extends SmartAccount | undefined,
+  accountOverride extends SmartAccount | undefined = undefined,
+>(
+  client: Client<Transport, Chain | undefined, account>,
+  parameters: EstimateUserOperationGasParameters<
+    account,
+    accountOverride,
+    calls
+  >,
+): Promise<EstimateUserOperationGasReturnType<account, accountOverride>> {
+  const { account: account_ = client.account } = parameters
+
+  if (!account_) throw new AccountNotFoundError()
+  const account = parseAccount(account_)
+
+  const request = await getAction(
+    client,
+    prepareUserOperation,
+    'prepareUserOperation',
+  )({
+    ...parameters,
+    parameters: ['factory', 'nonce', 'paymaster', 'signature'],
+  } as unknown as PrepareUserOperationParameters)
+
+  try {
+    const result = await client.request({
+      method: 'eth_estimateUserOperationGas',
+      params: [
+        formatUserOperationRequest(request as UserOperation),
+        account.entryPoint.address,
+      ],
+    })
+    return formatUserOperationGas(result) as EstimateUserOperationGasReturnType<
+      account,
+      accountOverride
+    >
+  } catch (error) {
+    throw getUserOperationError(error as BaseError, {
+      ...(request as UserOperation),
+      calls: parameters.calls,
+    })
+  }
+}

package/account-abstraction/actions/bundler/getSupportedEntryPoints.ts

@@ -0,0 +1,33 @@
+import type { Address } from 'abitype'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+
+export type GetSupportedEntryPointsReturnType = readonly Address[]
+export type GetSupportedEntryPointsErrorType = RequestErrorType | ErrorType
+
+/**
+ * Returns the EntryPoints that the bundler supports.
+ *
+ * - Docs: https://viem.sh/actions/bundler/getSupportedEntryPoints
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetSupportedEntryPointsParameters}
+ * @returns Supported Entry Points. {@link GetSupportedEntryPointsReturnType}
+ *
+ * @example
+ * import { createBundlerClient, http, parseEther } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getSupportedEntryPoints } from 'viem/actions'
+ *
+ * const bundlerClient = createBundlerClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const addresses = await getSupportedEntryPoints(bundlerClient)
+ */
+export function getSupportedEntryPoints(client: Client<Transport>) {
+  return client.request({ method: 'eth_supportedEntryPoints' })
+}

package/account-abstraction/actions/bundler/getUserOperation.ts

@@ -0,0 +1,85 @@
+import type { Address } from 'abitype'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hash } from '../../../types/misc.js'
+import type { Prettify } from '../../../types/utils.js'
+import type { RequestErrorType } from '../../../utils/buildRequest.js'
+import {
+  UserOperationNotFoundError,
+  type UserOperationNotFoundErrorType,
+} from '../../errors/userOperation.js'
+import type { UserOperation } from '../../types/userOperation.js'
+import { formatUserOperation } from '../../utils/formatters/userOperation.js'
+
+export type GetUserOperationParameters = {
+  /** The hash of the User Operation. */
+  hash: Hash
+}
+
+export type GetUserOperationReturnType = Prettify<{
+  /** The block hash the User Operation was included on. */
+  blockHash: Hash
+  /** The block number the User Operation was included on. */
+  blockNumber: bigint
+  /** The EntryPoint which handled the User Operation. */
+  entryPoint: Address
+  /** The hash of the transaction which included the User Operation. */
+  transactionHash: Hash
+  /** The User Operation. */
+  userOperation: UserOperation
+}>
+
+export type GetUserOperationErrorType =
+  | RequestErrorType
+  | UserOperationNotFoundErrorType
+  | ErrorType
+
+/**
+ * Retrieves information about a User Operation given a hash.
+ *
+ * - Docs: https://viem.sh/docs/actions/bundler/getUserOperation
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetUserOperationParameters}
+ * @returns The receipt. {@link GetUserOperationReturnType}
+ *
+ * @example
+ * import { createBundlerClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getUserOperation } from 'viem/actions
+ *
+ * const client = createBundlerClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const receipt = await getUserOperation(client, {
+ *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
+ * })
+ */
+export async function getUserOperation(
+  client: Client<Transport>,
+  { hash }: GetUserOperationParameters,
+) {
+  const result = await client.request(
+    {
+      method: 'eth_getUserOperationByHash',
+      params: [hash],
+    },
+    { dedupe: true },
+  )
+
+  if (!result) throw new UserOperationNotFoundError({ hash })
+
+  const { blockHash, blockNumber, entryPoint, transactionHash, userOperation } =
+    result
+
+  return {
+    blockHash,
+    blockNumber: BigInt(blockNumber),
+    entryPoint,
+    transactionHash,
+    userOperation: formatUserOperation(userOperation),
+  }
+}