viem 2.17.10 → 2.18.0

package/account-abstraction/utils/userOperation/getUserOperationHash.ts

@@ -0,0 +1,138 @@
+import type { Address } from 'abitype'
+import type { Hash } from '../../../types/misc.js'
+import { encodeAbiParameters } from '../../../utils/abi/encodeAbiParameters.js'
+import { concat } from '../../../utils/data/concat.js'
+import { pad } from '../../../utils/data/pad.js'
+import { numberToHex } from '../../../utils/encoding/toHex.js'
+import { keccak256 } from '../../../utils/hash/keccak256.js'
+import type { EntryPointVersion } from '../../types/entryPointVersion.js'
+import type { UserOperation } from '../../types/userOperation.js'
+
+export type GetUserOperationHashParameters<
+  entryPointVersion extends EntryPointVersion = EntryPointVersion,
+> = {
+  chainId: number
+  entryPointAddress: Address
+  entryPointVersion: entryPointVersion | EntryPointVersion
+  userOperation: UserOperation<entryPointVersion>
+}
+
+export type GetUserOperationHashReturnType = Hash
+
+export function getUserOperationHash<
+  entryPointVersion extends EntryPointVersion,
+>(
+  parameters: GetUserOperationHashParameters<entryPointVersion>,
+): GetUserOperationHashReturnType {
+  const { chainId, entryPointAddress, entryPointVersion } = parameters
+  const userOperation = parameters.userOperation as UserOperation
+  const {
+    callData,
+    callGasLimit,
+    initCode,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    paymasterAndData,
+    preVerificationGas,
+    sender,
+    verificationGasLimit,
+  } = userOperation
+
+  const packedUserOp = (() => {
+    if (entryPointVersion === '0.6') {
+      return encodeAbiParameters(
+        [
+          { type: 'address' },
+          { type: 'uint256' },
+          { type: 'bytes32' },
+          { type: 'bytes32' },
+          { type: 'uint256' },
+          { type: 'uint256' },
+          { type: 'uint256' },
+          { type: 'uint256' },
+          { type: 'uint256' },
+          { type: 'bytes32' },
+        ],
+        [
+          sender,
+          nonce,
+          keccak256(initCode ?? '0x'),
+          keccak256(callData ?? '0x'),
+          callGasLimit,
+          verificationGasLimit,
+          preVerificationGas,
+          maxFeePerGas,
+          maxPriorityFeePerGas,
+          keccak256(paymasterAndData ?? '0x'),
+        ],
+      )
+    }
+
+    if (entryPointVersion === '0.7') {
+      const accountGasLimits = concat([
+        pad(numberToHex(userOperation.verificationGasLimit), { size: 16 }),
+        pad(numberToHex(userOperation.callGasLimit), { size: 16 }),
+      ])
+      const callData_hashed = keccak256(callData)
+      const gasFees = concat([
+        pad(numberToHex(userOperation.maxPriorityFeePerGas), { size: 16 }),
+        pad(numberToHex(userOperation.maxFeePerGas), { size: 16 }),
+      ])
+      const initCode_hashed = keccak256(
+        userOperation.factory && userOperation.factoryData
+          ? concat([userOperation.factory, userOperation.factoryData])
+          : '0x',
+      )
+      const paymasterAndData_hashed = keccak256(
+        userOperation.paymaster
+          ? concat([
+              userOperation.paymaster,
+              pad(
+                numberToHex(userOperation.paymasterVerificationGasLimit || 0),
+                {
+                  size: 16,
+                },
+              ),
+              pad(numberToHex(userOperation.paymasterPostOpGasLimit || 0), {
+                size: 16,
+              }),
+              userOperation.paymasterData || '0x',
+            ])
+          : '0x',
+      )
+
+      return encodeAbiParameters(
+        [
+          { type: 'address' },
+          { type: 'uint256' },
+          { type: 'bytes32' },
+          { type: 'bytes32' },
+          { type: 'bytes32' },
+          { type: 'uint256' },
+          { type: 'bytes32' },
+          { type: 'bytes32' },
+        ],
+        [
+          sender,
+          nonce,
+          initCode_hashed,
+          callData_hashed,
+          accountGasLimits,
+          preVerificationGas,
+          gasFees,
+          paymasterAndData_hashed,
+        ],
+      )
+    }
+
+    throw new Error(`entryPointVersion "${entryPointVersion}" not supported.`)
+  })()
+
+  return keccak256(
+    encodeAbiParameters(
+      [{ type: 'bytes32' }, { type: 'address' }, { type: 'uint256' }],
+      [keccak256(packedUserOp), entryPointAddress, BigInt(chainId)],
+    ),
+  )
+}

package/account-abstraction/utils/userOperation/toPackedUserOperation.ts

@@ -0,0 +1,64 @@
+import { concat } from '../../../utils/data/concat.js'
+import { pad } from '../../../utils/data/pad.js'
+import { numberToHex } from '../../../utils/index.js'
+import type {
+  PackedUserOperation,
+  UserOperation,
+} from '../../types/userOperation.js'
+
+export function toPackedUserOperation(
+  userOperation: UserOperation,
+): PackedUserOperation {
+  const {
+    callGasLimit,
+    callData,
+    factory,
+    factoryData,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    paymaster,
+    paymasterData,
+    paymasterPostOpGasLimit,
+    paymasterVerificationGasLimit,
+    sender,
+    signature = '0x',
+    verificationGasLimit,
+  } = userOperation
+
+  const accountGasLimits = concat([
+    pad(numberToHex(verificationGasLimit || 0n), { size: 16 }),
+    pad(numberToHex(callGasLimit || 0n), { size: 16 }),
+  ])
+  const initCode =
+    factory && factoryData ? concat([factory, factoryData]) : '0x'
+  const gasFees = concat([
+    pad(numberToHex(maxPriorityFeePerGas || 0n), { size: 16 }),
+    pad(numberToHex(maxFeePerGas || 0n), { size: 16 }),
+  ])
+  const nonce = userOperation.nonce ?? 0n
+  const paymasterAndData = paymaster
+    ? concat([
+        paymaster,
+        pad(numberToHex(paymasterVerificationGasLimit || 0n), {
+          size: 16,
+        }),
+        pad(numberToHex(paymasterPostOpGasLimit || 0n), {
+          size: 16,
+        }),
+        paymasterData || '0x',
+      ])
+    : '0x'
+  const preVerificationGas = userOperation.preVerificationGas ?? 0n
+
+  return {
+    accountGasLimits,
+    callData,
+    initCode,
+    gasFees,
+    nonce,
+    paymasterAndData,
+    preVerificationGas,
+    sender,
+    signature,
+  }
+}

package/accounts/index.ts

@@ -35,7 +35,7 @@ export {
   type PrivateKeyToAccountErrorType,
   privateKeyToAccount,
 } from './privateKeyToAccount.js'
-export { type ToAccountErrorType, toAccount } from './toAccount.js'
+
 export type {
   Account,
   AccountSource,

package/accounts/privateKeyToAccount.ts

@@ -11,6 +11,7 @@ import {
   type PublicKeyToAddressErrorType,
   publicKeyToAddress,
 } from './utils/publicKeyToAddress.js'
+import { type SignErrorType, sign } from './utils/sign.js'
 import { type SignMessageErrorType, signMessage } from './utils/signMessage.js'
 import {
   type SignTransactionErrorType,
@@ -29,6 +30,7 @@ export type PrivateKeyToAccountErrorType =
   | ToAccountErrorType
   | ToHexErrorType
   | PublicKeyToAddressErrorType
+  | SignErrorType
   | SignMessageErrorType
   | SignTransactionErrorType
   | SignTypedDataErrorType
@@ -50,6 +52,9 @@ export function privateKeyToAccount(
   const account = toAccount({
     address,
     nonceManager,
+    async sign({ hash }) {
+      return sign({ hash, privateKey, to: 'hex' })
+    },
     async signMessage({ message }) {
       return signMessage({ message, privateKey })
     },

package/accounts/toAccount.ts

@@ -1,3 +1,5 @@
+// TODO(v3): Rename to `toLocalAccount` + add `source` property to define source (privateKey, mnemonic, hdKey, etc).
+
 import type { Address } from 'abitype'
 
 import {
@@ -48,6 +50,7 @@ export function toAccount<accountSource extends AccountSource>(
   return {
     address: source.address,
     nonceManager: source.nonceManager,
+    sign: source.sign,
     signMessage: source.signMessage,
     signTransaction: source.signTransaction,
     signTypedData: source.signTypedData,

package/accounts/types.ts

@@ -1,5 +1,6 @@
 import type { Address, TypedData } from 'abitype'
 
+import type { SmartAccount } from '../account-abstraction/accounts/types.js'
 import type { HDKey } from '../types/account.js'
 import type { Hash, Hex, SignableMessage } from '../types/misc.js'
 import type {
@@ -7,19 +8,25 @@ import type {
   TransactionSerialized,
 } from '../types/transaction.js'
 import type { TypedDataDefinition } from '../types/typedData.js'
-import type { IsNarrowable, OneOf } from '../types/utils.js'
+import type { IsNarrowable, OneOf, Prettify } from '../types/utils.js'
 import type { NonceManager } from '../utils/nonceManager.js'
 import type { GetTransactionType } from '../utils/transaction/getTransactionType.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
 
 export type Account<address extends Address = Address> = OneOf<
-  JsonRpcAccount<address> | LocalAccount<string, address>
+  JsonRpcAccount<address> | LocalAccount<string, address> | SmartAccount
 >
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Sources
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type AccountSource = Address | CustomSource
 export type CustomSource = {
   address: Address
   nonceManager?: NonceManager | undefined
+  // TODO(v3): Make `sign` required.
+  sign?: (({ hash }: { hash: Hash }) => Promise<Hash>) | undefined
   signMessage: ({ message }: { message: SignableMessage }) => Promise<Hash>
   signTransaction: <
     serializer extends
@@ -48,6 +55,10 @@ export type CustomSource = {
   ) => Promise<Hash>
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Accounts
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type JsonRpcAccount<address extends Address = Address> = {
   address: address
   type: 'json-rpc'
@@ -56,16 +67,22 @@ export type JsonRpcAccount<address extends Address = Address> = {
 export type LocalAccount<
   source extends string = string,
   address extends Address = Address,
-> = CustomSource & {
-  address: address
-  publicKey: Hex
-  source: source
-  type: 'local'
-}
+> = Prettify<
+  CustomSource & {
+    address: address
+    publicKey: Hex
+    source: source
+    type: 'local'
+  }
+>
 
-export type HDAccount = LocalAccount<'hd'> & {
-  getHdKey(): HDKey
-}
+export type HDAccount = Prettify<
+  LocalAccount<'hd'> & {
+    getHdKey(): HDKey
+    // TODO(v3): This will be redundant.
+    sign: NonNullable<CustomSource['sign']>
+  }
+>
 
 export type HDOptions =
   | {
@@ -85,4 +102,9 @@ export type HDOptions =
       path: `m/44'/60'/${string}`
     }
 
-export type PrivateKeyAccount = LocalAccount<'privateKey'>
+export type PrivateKeyAccount = Prettify<
+  LocalAccount<'privateKey'> & {
+    // TODO(v3): This will be redundant.
+    sign: NonNullable<CustomSource['sign']>
+  }
+>

package/accounts/utils/parseAccount.ts

@@ -5,7 +5,10 @@ import type { Account } from '../types.js'
 
 export type ParseAccountErrorType = ErrorType
 
-export function parseAccount(account: Address | Account): Account {
-  if (typeof account === 'string') return { address: account, type: 'json-rpc' }
-  return account
+export function parseAccount<accountOrAddress extends Address | Account>(
+  account: accountOrAddress,
+): accountOrAddress extends Address ? Account : accountOrAddress {
+  if (typeof account === 'string')
+    return { address: account, type: 'json-rpc' } as any
+  return account as any
 }

package/accounts/utils/sign.ts

@@ -3,17 +3,27 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
 import type { ErrorType } from '../../errors/utils.js'
-import type { Hex, Signature } from '../../types/misc.js'
-import { type ToHexErrorType, numberToHex } from '../../utils/encoding/toHex.js'
+import type { ByteArray, Hex, Signature } from '../../types/misc.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+import { serializeSignature } from '../../utils/signature/serializeSignature.js'
 
-export type SignParameters = {
+type To = 'object' | 'bytes' | 'hex'
+
+export type SignParameters<to extends To = 'object'> = {
   hash: Hex
   privateKey: Hex
+  to?: to | To | undefined
 }
 
-export type SignReturnType = Signature
+export type SignReturnType<to extends To = 'object'> =
+  | (to extends 'object' ? Signature : never)
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
 
-export type SignErrorType = ToHexErrorType | ErrorType
+export type SignErrorType = NumberToHexErrorType | ErrorType
 
 /**
  * @description Signs a hash with a given private key.
@@ -23,15 +33,21 @@ export type SignErrorType = ToHexErrorType | ErrorType
  *
  * @returns The signature.
  */
-export async function sign({
+export async function sign<to extends To = 'object'>({
   hash,
   privateKey,
-}: SignParameters): Promise<SignReturnType> {
+  to = 'object',
+}: SignParameters<to>): Promise<SignReturnType<to>> {
   const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2))
-  return {
+  const signature = {
     r: numberToHex(r, { size: 32 }),
     s: numberToHex(s, { size: 32 }),
     v: recovery ? 28n : 27n,
     yParity: recovery,
   }
+  return (() => {
+    if (to === 'bytes' || to === 'hex')
+      return serializeSignature({ ...signature, to })
+    return signature
+  })() as SignReturnType<to>
 }

package/accounts/utils/signMessage.ts

@@ -4,10 +4,6 @@ import {
   type HashMessageErrorType,
   hashMessage,
 } from '../../utils/signature/hashMessage.js'
-import {
-  type SerializeSignatureErrorType,
-  serializeSignature,
-} from '../../utils/signature/serializeSignature.js'
 
 import { type SignErrorType, sign } from './sign.js'
 
@@ -23,7 +19,6 @@ export type SignMessageReturnType = Hex
 export type SignMessageErrorType =
   | SignErrorType
   | HashMessageErrorType
-  | SerializeSignatureErrorType
   | ErrorType
 
 /**
@@ -36,6 +31,5 @@ export async function signMessage({
   message,
   privateKey,
 }: SignMessageParameters): Promise<SignMessageReturnType> {
-  const signature = await sign({ hash: hashMessage(message), privateKey })
-  return serializeSignature(signature)
+  return await sign({ hash: hashMessage(message), privateKey, to: 'hex' })
 }

package/accounts/utils/signTypedData.ts

@@ -6,10 +6,6 @@ import {
   type HashTypedDataErrorType,
   hashTypedData,
 } from '../../utils/signature/hashTypedData.js'
-import {
-  type SerializeSignatureErrorType,
-  serializeSignature,
-} from '../../utils/signature/serializeSignature.js'
 
 import type { ErrorType } from '../../errors/utils.js'
 import { type SignErrorType, sign } from './sign.js'
@@ -27,7 +23,6 @@ export type SignTypedDataReturnType = Hex
 export type SignTypedDataErrorType =
   | HashTypedDataErrorType
   | SignErrorType
-  | SerializeSignatureErrorType
   | ErrorType
 
 /**
@@ -44,9 +39,9 @@ export async function signTypedData<
 ): Promise<SignTypedDataReturnType> {
   const { privateKey, ...typedData } =
     parameters as unknown as SignTypedDataParameters
-  const signature = await sign({
+  return await sign({
     hash: hashTypedData(typedData),
     privateKey,
+    to: 'hex',
   })
-  return serializeSignature(signature)
 }

package/actions/wallet/sendTransaction.ts

@@ -6,7 +6,12 @@ import {
 import type { SignTransactionErrorType } from '../../accounts/utils/signTransaction.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import { AccountNotFoundError } from '../../errors/account.js'
+import {
+  AccountNotFoundError,
+  type AccountNotFoundErrorType,
+  AccountTypeNotSupportedError,
+  type AccountTypeNotSupportedErrorType,
+} from '../../errors/account.js'
 import type { BaseError } from '../../errors/base.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { GetAccountParameter } from '../../types/account.js'
@@ -73,6 +78,8 @@ export type SendTransactionReturnType = Hash
 export type SendTransactionErrorType =
   | ParseAccountErrorType
   | GetTransactionErrorReturnType<
+      | AccountNotFoundErrorType
+      | AccountTypeNotSupportedErrorType
       | AssertCurrentChainErrorType
       | AssertRequestErrorType
       | GetChainIdErrorType
@@ -172,6 +179,36 @@ export async function sendTransaction<
       })
     }
 
+    if (account.type === 'json-rpc') {
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format
+      const format = chainFormat || formatTransactionRequest
+
+      const request = format({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        blobs,
+        chainId,
+        data,
+        from: account.address,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+      } as TransactionRequest)
+      return await client.request(
+        {
+          method: 'eth_sendTransaction',
+          params: [request],
+        },
+        { retryCount: 0 },
+      )
+    }
+
     if (account.type === 'local') {
       // Prepare the request for signing (assign appropriate fees, etc.)
       const request = await getAction(
@@ -210,34 +247,18 @@ export async function sendTransaction<
       })
     }
 
-    const chainFormat = client.chain?.formatters?.transactionRequest?.format
-    const format = chainFormat || formatTransactionRequest
+    if (account.type === 'smart')
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          'Consider using the `sendUserOperation` Action instead.',
+        ],
+        docsPath: '/docs/actions/bundler/sendUserOperation',
+        type: 'smart',
+      })
 
-    const request = format({
-      // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract(rest, { format: chainFormat }),
-      accessList,
-      blobs,
-      chainId,
-      data,
-      from: account.address,
-      gas,
-      gasPrice,
-      maxFeePerBlobGas,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to,
-      value,
-    } as TransactionRequest)
-    return await client.request(
-      {
-        method: 'eth_sendTransaction',
-        params: [request],
-      },
-      { retryCount: 0 },
-    )
+    throw new Error('incompatible account type.')
   } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError) throw err
     throw getTransactionError(err as BaseError, {
       ...parameters,
       account,

package/actions/wallet/signMessage.ts

@@ -94,7 +94,8 @@ export async function signMessage<
       docsPath: '/docs/actions/wallet/signMessage',
     })
   const account = parseAccount(account_)
-  if (account.type === 'local') return account.signMessage({ message })
+
+  if (account.signMessage) return account.signMessage({ message })
 
   const message_ = (() => {
     if (typeof message === 'string') return stringToHex(message)

package/actions/wallet/signTransaction.ts

@@ -155,7 +155,7 @@ export async function signTransaction<
   const format =
     formatters?.transactionRequest?.format || formatTransactionRequest
 
-  if (account.type === 'local') {
+  if (account.signTransaction)
     return account.signTransaction(
       {
         ...transaction,
@@ -163,7 +163,6 @@ export async function signTransaction<
       } as TransactionSerializable,
       { serializer: client.chain?.serializers?.transaction },
     ) as Promise<SignTransactionReturnType>
-  }
 
   return await client.request(
     {

package/actions/wallet/signTypedData.ts

@@ -181,7 +181,7 @@ export async function signTypedData<
   // as we can't statically check this with TypeScript.
   validateTypedData({ domain, message, primaryType, types })
 
-  if (account.type === 'local')
+  if (account.signTypedData)
     return account.signTypedData({ domain, message, primaryType, types })
 
   const typedData = serializeTypedData({ domain, message, primaryType, types })

package/chains/definitions/bobaSepolia.ts

@@ -0,0 +1,20 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const bobaSepolia = /*#__PURE__*/ defineChain({
+  id: 28882,
+  name: 'Boba Sepolia',
+  nativeCurrency: {
+    name: 'Ether',
+    symbol: 'ETH',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['https://sepolia.boba.network'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'BOBAScan',
+      url: 'https://testnet.bobascan.com',
+    },
+  },
+})

package/chains/index.ts

@@ -40,6 +40,7 @@ export { blast } from './definitions/blast.js'
 export { blastSepolia } from './definitions/blastSepolia.js'
 export { bob } from './definitions/bob.js'
 export { boba } from './definitions/boba.js'
+export { bobaSepolia } from './definitions/bobaSepolia.js'
 export { bronos } from './definitions/bronos.js'
 export { bronosTestnet } from './definitions/bronosTestnet.js'
 export { bsc } from './definitions/bsc.js'

package/clients/decorators/public.ts

@@ -945,7 +945,7 @@ export type PublicActions<
     type extends FeeValuesType = 'eip1559',
   >(
     args?: EstimateFeesPerGasParameters<chain, chainOverride, type> | undefined,
-  ) => Promise<EstimateFeesPerGasReturnType>
+  ) => Promise<EstimateFeesPerGasReturnType<type>>
   /**
    * Returns a list of logs or hashes based on a [Filter](/docs/glossary/terms#filter) since the last time it was called.
    *
@@ -1417,11 +1417,10 @@ export type PublicActions<
     >,
   ) => Promise<
     PrepareTransactionRequestReturnType<
-      Chain,
+      chain,
       account,
       chainOverride,
       accountOverride,
-      // @ts-expect-error
       request
     >
   >