viem 2.15.1 → 2.16.1

package/_types/zksync/formatters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../zksync/formatters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAU5C,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EACV,oBAAoB,EACpB,oCAAoC,EAEpC,iBAAiB,EAGlB,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,UAAU;;;;0BAID,IAAI,EAAE,GAAG,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;0BAGjC,IAAI,EAAE,GAAG,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2HZ,CAAA"}
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../zksync/formatters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAU5C,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EACV,oBAAoB,EACpB,oCAAoC,EAEpC,iBAAiB,EAGlB,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,UAAU;;;;0BAID,IAAI,EAAE,GAAG,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8HjB,CAAA"}

package/actions/public/createEventFilter.ts

@@ -189,15 +189,15 @@ export async function createEventFilter<
 
   let topics: LogTopic[] = []
   if (events) {
-    topics = [
-      (events as AbiEvent[]).flatMap((event) =>
-        encodeEventTopics({
-          abi: [event],
-          eventName: (event as AbiEvent).name,
-          args,
-        } as EncodeEventTopicsParameters),
-      ),
-    ]
+    const encoded = (events as AbiEvent[]).flatMap((event) =>
+      encodeEventTopics({
+        abi: [event],
+        eventName: (event as AbiEvent).name,
+        args,
+      } as EncodeEventTopicsParameters),
+    )
+    // TODO: Clean up type casting
+    topics = [encoded as LogTopic]
     if (event) topics = topics[0] as LogTopic[]
   }
 

package/actions/public/getLogs.ts

@@ -167,15 +167,15 @@ export async function getLogs<
 
   let topics: LogTopic[] = []
   if (events) {
-    topics = [
-      (events as AbiEvent[]).flatMap((event) =>
-        encodeEventTopics({
-          abi: [event],
-          eventName: (event as AbiEvent).name,
-          args,
-        } as EncodeEventTopicsParameters),
-      ),
-    ]
+    const encoded = (events as AbiEvent[]).flatMap((event) =>
+      encodeEventTopics({
+        abi: [event],
+        eventName: (event as AbiEvent).name,
+        args,
+      } as EncodeEventTopicsParameters),
+    )
+    // TODO: Clean up type casting
+    topics = [encoded as LogTopic]
     if (event) topics = topics[0] as LogTopic[]
   }
 

package/actions/public/getTransactionCount.ts

@@ -40,7 +40,7 @@ export type GetTransactionCountErrorType =
   | ErrorType
 
 /**
- * Returns the number of [Transactions](https://viem.sh/docs/glossary/terms#transaction) an Account has broadcast / sent.
+ * Returns the number of [Transactions](https://viem.sh/docs/glossary/terms#transaction) an Account has sent.
  *
  * - Docs: https://viem.sh/docs/actions/public/getTransactionCount
  * - JSON-RPC Methods: [`eth_getTransactionCount`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactioncount)

package/actions/public/verifyHash.ts

@@ -8,6 +8,7 @@ import { CallExecutionError } from '../../errors/contract.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { ByteArray, Hex, Signature } from '../../types/misc.js'
+import type { OneOf } from '../../types/utils.js'
 import {
   type EncodeDeployDataErrorType,
   encodeDeployData,
@@ -19,8 +20,11 @@ import {
 import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
 import { type ToHexErrorType, bytesToHex } from '../../utils/encoding/toHex.js'
 import { getAction } from '../../utils/getAction.js'
+import { isErc6492Signature } from '../../utils/signature/isErc6492Signature.js'
+import { serializeErc6492Signature } from '../../utils/signature/serializeErc6492Signature.js'
 import { serializeSignature } from '../../utils/signature/serializeSignature.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
+import { getCode } from './getCode.js'
 
 export type VerifyHashParameters = Pick<
   CallParameters,
@@ -32,7 +36,7 @@ export type VerifyHashParameters = Pick<
   hash: Hex
   /** The signature that was generated by signing the message with the address's private key. */
   signature: Hex | ByteArray | Signature
-}
+} & OneOf<{ factory: Address; factoryData: Hex } | {}>
 
 export type VerifyHashReturnType = boolean
 
@@ -53,8 +57,10 @@ export type VerifyHashErrorType =
  */
 export async function verifyHash<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
-  { address, hash, signature, ...callRequest }: VerifyHashParameters,
+  parameters: VerifyHashParameters,
 ): Promise<VerifyHashReturnType> {
+  const { address, factory, factoryData, hash, signature, ...rest } = parameters
+
   const signatureHex = (() => {
     if (isHex(signature)) return signature
     if (typeof signature === 'object' && 'r' in signature && 's' in signature)
@@ -62,6 +68,27 @@ export async function verifyHash<TChain extends Chain | undefined>(
     return bytesToHex(signature)
   })()
 
+  const wrappedSignature = await (async () => {
+    // If no `factory` or `factoryData` is provided, it is assumed that the
+    // address is not a Smart Account, or the Smart Account is already deployed.
+    if (!factory && !factoryData) return signatureHex
+
+    // If the signature is already wrapped, return the signature.
+    if (isErc6492Signature(signatureHex)) return signatureHex
+
+    const bytecode = await getAction(client, getCode, 'getCode')({ address })
+    // If the Smart Account is deployed, return the plain signature.
+    if (bytecode) return signatureHex
+
+    // If the Smart Account is not deployed, wrap the signature with a 6492 wrapper
+    // to perform counterfactual validation.
+    return serializeErc6492Signature({
+      address: factory!,
+      data: factoryData!,
+      signature: signatureHex,
+    })
+  })()
+
   try {
     const { data } = await getAction(
       client,
@@ -70,10 +97,10 @@ export async function verifyHash<TChain extends Chain | undefined>(
     )({
       data: encodeDeployData({
         abi: universalSignatureValidatorAbi,
-        args: [address, hash, signatureHex],
+        args: [address, hash, wrappedSignature],
         bytecode: universalSignatureValidatorByteCode,
       }),
-      ...callRequest,
+      ...rest,
     } as unknown as CallParameters)
 
     return isBytesEqual(data ?? '0x0', '0x1')

package/actions/public/verifyMessage.ts

@@ -50,11 +50,20 @@ export type VerifyMessageErrorType =
  */
 export async function verifyMessage<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
-  { address, message, signature, ...callRequest }: VerifyMessageParameters,
+  {
+    address,
+    message,
+    factory,
+    factoryData,
+    signature,
+    ...callRequest
+  }: VerifyMessageParameters,
 ): Promise<VerifyMessageReturnType> {
   const hash = hashMessage(message)
   return verifyHash(client, {
     address,
+    factory: factory!,
+    factoryData: factoryData!,
     hash,
     signature,
     ...callRequest,

package/actions/public/verifyTypedData.ts

@@ -53,6 +53,8 @@ export async function verifyTypedData<
 ): Promise<VerifyTypedDataReturnType> {
   const {
     address,
+    factory,
+    factoryData,
     signature,
     message,
     primaryType,
@@ -63,6 +65,8 @@ export async function verifyTypedData<
   const hash = hashTypedData({ message, primaryType, types, domain })
   return verifyHash(client, {
     address,
+    factory: factory!,
+    factoryData: factoryData!,
     hash,
     signature,
     ...callRequest,

package/actions/public/watchEvent.ts

@@ -318,15 +318,15 @@ export function watchEvent<
         const events_ = events ?? (event ? [event] : undefined)
         let topics: LogTopic[] = []
         if (events_) {
-          topics = [
-            (events_ as AbiEvent[]).flatMap((event) =>
-              encodeEventTopics({
-                abi: [event],
-                eventName: (event as AbiEvent).name,
-                args,
-              } as EncodeEventTopicsParameters),
-            ),
-          ]
+          const encoded = (events_ as AbiEvent[]).flatMap((event) =>
+            encodeEventTopics({
+              abi: [event],
+              eventName: (event as AbiEvent).name,
+              args,
+            } as EncodeEventTopicsParameters),
+          )
+          // TODO: Clean up type casting
+          topics = [encoded as LogTopic]
           if (event) topics = topics[0] as LogTopic[]
         }
 

package/actions/wallet/sendTransaction.ts

@@ -218,6 +218,7 @@ export async function sendTransaction<
       ...extract(rest, { format: chainFormat }),
       accessList,
       blobs,
+      chainId,
       data,
       from: account.address,
       gas,

package/chains/definitions/zetachain.ts

@@ -13,6 +13,12 @@ export const zetachain = /*#__PURE__*/ defineChain({
       http: ['https://zetachain-evm.blockpi.network/v1/rpc/public'],
     },
   },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 1632781,
+    },
+  },
   blockExplorers: {
     default: {
       name: 'ZetaScan',

package/chains/definitions/zetachainAthensTestnet.ts

@@ -13,6 +13,12 @@ export const zetachainAthensTestnet = /*#__PURE__*/ defineChain({
       http: ['https://zetachain-athens-evm.blockpi.network/v1/rpc/public'],
     },
   },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 2715217,
+    },
+  },
   blockExplorers: {
     default: {
       name: 'ZetaScan',

package/chains/definitions/zircuitTestnet.ts

@@ -0,0 +1,24 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const zircuitTestnet = /*#__PURE__*/ defineChain({
+  id: 48899,
+  name: 'Zircuit Testnet',
+  nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://zircuit1.p2pify.com'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Zircuit Explorer',
+      url: 'https://explorer.zircuit.com',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 6040287,
+    },
+  },
+})

package/chains/index.ts

@@ -293,6 +293,7 @@ export { zkSyncTestnet } from './definitions/zkSyncTestnet.js'
 export { zora } from './definitions/zora.js'
 export { zoraSepolia } from './definitions/zoraSepolia.js'
 export { zoraTestnet } from './definitions/zoraTestnet.js'
+export { zircuitTestnet } from './definitions/zircuitTestnet.js'
 
 //////////////////////////////////////////////////////////////////////////////////////
 // Required type exports to prevent TypeScript error "TS2742".

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.15.1'
+export const version = '2.16.1'

package/experimental/index.ts

@@ -36,23 +36,35 @@ export {
 } from './eip5792/decorators/eip5792.js'
 
 export {
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureErrorType } from 'viem'` instead. */
   type ParseErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureParameters } from 'viem'` instead. */
   type ParseErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureReturnType } from 'viem'` instead. */
   type ParseErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { parseErc6492Signature } from 'viem'` instead. */
   parseErc6492Signature,
-} from './erc6492/parseErc6492Signature.js'
+} from '../utils/signature/parseErc6492Signature.js'
 export {
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureErrorType } from 'viem'` instead. */
   type IsErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureParameters } from 'viem'` instead. */
   type IsErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureReturnType } from 'viem'` instead. */
   type IsErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { isErc6492Signature } from 'viem'` instead. */
   isErc6492Signature,
-} from './erc6492/isErc6492Signature.js'
+} from '../utils/signature/isErc6492Signature.js'
 export {
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureErrorType } from 'viem'` instead. */
   type SerializeErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureParameters } from 'viem'` instead. */
   type SerializeErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureReturnType } from 'viem'` instead. */
   type SerializeErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { serializeErc6492Signature } from 'viem'` instead. */
   serializeErc6492Signature,
-} from './erc6492/serializeErc6492Signature.js'
+} from '../utils/signature/serializeErc6492Signature.js'
 
 export {
   type IssuePermissionsParameters,
@@ -63,3 +75,9 @@ export {
   type WalletActionsErc7715,
   walletActionsErc7715,
 } from './erc7715/decorators/erc7715.js'
+
+export {
+  type SoladyActions,
+  type SoladyActionsParameters,
+  soladyActions,
+} from './solady/decorators/solady.js'

package/experimental/solady/actions/signMessage.ts

@@ -0,0 +1,151 @@
+import type { Address, TypedDataDomain } from 'abitype'
+import type { Account } from '../../../accounts/types.js'
+import { parseAccount } from '../../../accounts/utils/parseAccount.js'
+import {
+  type GetEip712DomainParameters,
+  getEip712Domain,
+} from '../../../actions/public/getEip712Domain.js'
+import { signTypedData } from '../../../actions/wallet/signTypedData.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../../errors/account.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { GetAccountParameter } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex, SignableMessage } from '../../../types/misc.js'
+import type { OneOf, RequiredBy } from '../../../types/utils.js'
+import { getAction } from '../../../utils/getAction.js'
+import { toPrefixedMessage } from '../../../utils/signature/toPrefixedMessage.js'
+import type { GetVerifierParameter } from '../types.js'
+
+export type SignMessageParameters<
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | undefined = Account | undefined,
+  verifier extends Address | undefined = Address | undefined,
+> = Pick<GetEip712DomainParameters, 'factory' | 'factoryData'> &
+  GetAccountParameter<account, accountOverride> & {
+    message: SignableMessage
+  } & OneOf<
+    | {
+        verifierDomain: RequiredBy<
+          TypedDataDomain,
+          'chainId' | 'name' | 'verifyingContract' | 'version'
+        >
+        verifier?: undefined
+      }
+    | (GetVerifierParameter<verifier> & {
+        verifierDomain?:
+          | RequiredBy<
+              TypedDataDomain,
+              'chainId' | 'name' | 'verifyingContract' | 'version'
+            >
+          | undefined
+      })
+  >
+
+export type SignMessageReturnType = Hex
+
+export type SignMessageErrorType = ErrorType
+
+/**
+ * Signs a [EIP-191](https://eips.ethereum.org/EIPS/eip-191) personal sign message via Solady's [ERC1271 `PersonalSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L154-L166).
+ *
+ * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+ *
+ * - Docs: https://viem.sh/experimental/solady/signMessage
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage) to verify the signature,
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignMessageParameters}
+ * @returns The signed message. {@link SignMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const signature = await signMessage(client, {
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   message: 'hello world',
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const signature = await signMessage(client, {
+ *   message: 'hello world',
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
+export async function signMessage<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  accountOverride extends Account | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SignMessageParameters<account, accountOverride>,
+): Promise<SignMessageReturnType> {
+  const {
+    account: account_ = client.account,
+    factory,
+    factoryData,
+    message,
+    verifier,
+  } = parameters
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/solady/signMessage',
+    })
+  const account = parseAccount(account_)
+
+  const domain = await (async () => {
+    if (parameters.verifierDomain) return parameters.verifierDomain
+    const {
+      domain: { salt, ...domain },
+    } = await getAction(
+      client,
+      getEip712Domain,
+      'getEip712Domain',
+    )({
+      address: verifier!,
+      factory,
+      factoryData,
+    })
+    return domain
+  })()
+
+  return getAction(
+    client,
+    signTypedData,
+    'signTypedData',
+  )({
+    account,
+    domain,
+    types: {
+      PersonalSign: [{ name: 'prefixed', type: 'bytes' }],
+    },
+    primaryType: 'PersonalSign',
+    message: {
+      prefixed: toPrefixedMessage(message),
+    },
+  })
+}