viem 2.17.10 → 2.18.0

package/utils/signature/serializeErc6492Signature.ts

@@ -1,20 +1,26 @@
 import type { Address } from 'abitype'
 import { erc6492MagicBytes } from '../../constants/bytes.js'
 import type { ErrorType } from '../../errors/utils.js'
-import type { Hex } from '../../types/misc.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
 import { encodeAbiParameters } from '../abi/encodeAbiParameters.js'
 import { concatHex } from '../data/concat.js'
+import { hexToBytes } from '../encoding/toBytes.js'
 
-export type SerializeErc6492SignatureParameters = {
+type To = 'bytes' | 'hex'
+
+export type SerializeErc6492SignatureParameters<to extends To = 'hex'> = {
   /** The ERC-4337 Account Factory address to use for counterfactual verification. */
   address: Address
   /** Calldata to pass to deploy account (if not deployed) for counterfactual verification. */
   data: Hex
   /** The original signature. */
   signature: Hex
+  to?: to | To | undefined
 }
 
-export type SerializeErc6492SignatureReturnType = Hex
+export type SerializeErc6492SignatureReturnType<to extends To = 'hex'> =
+  | (to extends 'hex' ? Hex : never)
+  | (to extends 'bytes' ? ByteArray : never)
 
 export type SerializeErc6492SignatureErrorType = ErrorType
 
@@ -28,15 +34,18 @@ export type SerializeErc6492SignatureErrorType = ErrorType
  * serializeSignature({ address: '0x...', data: '0x...', signature: '0x...' })
  * // '0x000000000000000000000000cafebabecafebabecafebabecafebabecafebabe000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000004deadbeef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041a461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b000000000000000000000000000000000000000000000000000000000000006492649264926492649264926492649264926492649264926492649264926492'
  */
-export function serializeErc6492Signature(
-  parameters: SerializeErc6492SignatureParameters,
-): SerializeErc6492SignatureReturnType {
-  const { address, data, signature } = parameters
-  return concatHex([
+export function serializeErc6492Signature<to extends To = 'hex'>(
+  parameters: SerializeErc6492SignatureParameters<to>,
+): SerializeErc6492SignatureReturnType<to> {
+  const { address, data, signature, to = 'hex' } = parameters
+  const signature_ = concatHex([
     encodeAbiParameters(
       [{ type: 'address' }, { type: 'bytes' }, { type: 'bytes' }],
       [address, data, signature],
     ),
     erc6492MagicBytes,
   ])
+
+  if (to === 'hex') return signature_ as SerializeErc6492SignatureReturnType<to>
+  return hexToBytes(signature_) as SerializeErc6492SignatureReturnType<to>
 }

package/utils/signature/serializeSignature.ts

@@ -1,10 +1,21 @@
 import { secp256k1 } from '@noble/curves/secp256k1'
 
 import type { ErrorType } from '../../errors/utils.js'
-import type { Hex, Signature } from '../../types/misc.js'
+import type { ByteArray, Hex, Signature } from '../../types/misc.js'
 import { type HexToBigIntErrorType, hexToBigInt } from '../encoding/fromHex.js'
+import { hexToBytes } from '../encoding/toBytes.js'
 import type { ToHexErrorType } from '../encoding/toHex.js'
 
+type To = 'bytes' | 'hex'
+
+export type SerializeSignatureParameters<to extends To = 'hex'> = Signature & {
+  to?: to | To | undefined
+}
+
+export type SerializeSignatureReturnType<to extends To = 'hex'> =
+  | (to extends 'hex' ? Hex : never)
+  | (to extends 'bytes' ? ByteArray : never)
+
 export type SerializeSignatureErrorType =
   | HexToBigIntErrorType
   | ToHexErrorType
@@ -24,14 +35,23 @@ export type SerializeSignatureErrorType =
  * })
  * // "0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c"
  */
-export function serializeSignature({ r, s, v, yParity }: Signature): Hex {
+export function serializeSignature<to extends To = 'hex'>({
+  r,
+  s,
+  to = 'hex',
+  v,
+  yParity,
+}: SerializeSignatureParameters<to>): SerializeSignatureReturnType<to> {
   const yParity_ = (() => {
     if (yParity === 0 || yParity === 1) return yParity
     if (v && (v === 27n || v === 28n || v >= 35n)) return v % 2n === 0n ? 1 : 0
     throw new Error('Invalid `v` or `yParity` value')
   })()
-  return `0x${new secp256k1.Signature(
+  const signature = `0x${new secp256k1.Signature(
     hexToBigInt(r),
     hexToBigInt(s),
-  ).toCompactHex()}${yParity_ === 0 ? '1b' : '1c'}`
+  ).toCompactHex()}${yParity_ === 0 ? '1b' : '1c'}` as const
+
+  if (to === 'hex') return signature as SerializeSignatureReturnType<to>
+  return hexToBytes(signature) as SerializeSignatureReturnType<to>
 }

package/utils/signature/verifyHash.ts

@@ -0,0 +1,54 @@
+import type { Address } from 'abitype'
+
+import type { ByteArray, Hash, Hex, Signature } from '../../types/misc.js'
+import { type GetAddressErrorType, getAddress } from '../address/getAddress.js'
+import {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from '../address/isAddressEqual.js'
+
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from './recoverAddress.js'
+
+export type VerifyHashParameters = {
+  /** The address that signed the original message. */
+  address: Address
+  /** The hash to be verified. */
+  hash: Hash
+  /** The signature that was generated by signing the message with the address's private key. */
+  signature: Hex | ByteArray | Signature
+}
+
+export type VerifyHashReturnType = boolean
+
+export type VerifyHashErrorType =
+  | IsAddressEqualErrorType
+  | GetAddressErrorType
+  | RecoverAddressErrorType
+  | ErrorType
+
+/**
+ * Verify that a message was signed by the provided address.
+ *
+ * Note:  Only supports Externally Owned Accounts. Does not support Contract Accounts.
+ *        It is highly recommended to use `publicClient.verifyHash` instead to ensure
+ *        wallet interoperability.
+ *
+ * - Docs {@link https://viem.sh/docs/utilities/verifyHash}
+ *
+ * @param parameters - {@link VerifyHashParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
+ */
+export async function verifyHash({
+  address,
+  hash,
+  signature,
+}: VerifyHashParameters): Promise<VerifyHashReturnType> {
+  return isAddressEqual(
+    getAddress(address),
+    await recoverAddress({ hash, signature }),
+  )
+}