viem 2.7.20 → 2.8.0

package/utils/blob/commitmentsToVersionedHashes.ts

@@ -0,0 +1,71 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import {
+  type CommitmentToVersionedHashErrorType,
+  commitmentToVersionedHash,
+} from './commitmentToVersionedHash.js'
+
+type To = 'hex' | 'bytes'
+
+export type CommitmentsToVersionedHashesParameters<
+  commitments extends Uint8Array[] | Hex[] = Uint8Array[] | Hex[],
+  to extends To | undefined = undefined,
+> = {
+  /** Commitments from blobs. */
+  commitments: commitments | Uint8Array[] | Hex[]
+  /** Return type. */
+  to?: to | To | undefined
+  /** Version to tag onto the hashes. */
+  version?: number
+}
+
+export type CommitmentsToVersionedHashesReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
+
+export type CommitmentsToVersionedHashesErrorType =
+  | CommitmentToVersionedHashErrorType
+  | ErrorType
+
+/**
+ * Transform a list of commitments to their versioned hashes.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   commitmentsToVersionedHashes,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const versionedHashes = commitmentsToVersionedHashes({ commitments })
+ * ```
+ */
+export function commitmentsToVersionedHashes<
+  const commitments extends Uint8Array[] | Hex[],
+  to extends To =
+    | (commitments extends Hex[] ? 'hex' : never)
+    | (commitments extends ByteArray[] ? 'bytes' : never),
+>(
+  parameters: CommitmentsToVersionedHashesParameters<commitments, to>,
+): CommitmentsToVersionedHashesReturnType<to> {
+  const { commitments, version } = parameters
+
+  const to =
+    parameters.to ?? (typeof commitments[0] === 'string' ? 'hex' : 'bytes')
+
+  const hashes: Uint8Array[] | Hex[] = []
+  for (const commitment of commitments) {
+    hashes.push(
+      commitmentToVersionedHash({
+        commitment,
+        to,
+        version,
+      }) as any,
+    )
+  }
+  return hashes as CommitmentsToVersionedHashesReturnType<to>
+}

package/utils/blob/fromBlobs.ts

@@ -0,0 +1,73 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { type CreateCursorErrorType, createCursor } from '../cursor.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type FromBlobsParameters<
+  blobs extends readonly Hex[] | readonly ByteArray[] =
+    | readonly Hex[]
+    | readonly ByteArray[],
+  to extends To | undefined = undefined,
+> = {
+  /** Blobs to transform to data. */
+  blobs: blobs | readonly Hex[] | readonly ByteArray[]
+  to?: to | To | undefined
+}
+
+export type FromBlobsReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray : never)
+  | (to extends 'hex' ? Hex : never)
+
+export type FromBlobsErrorType =
+  | BytesToHexErrorType
+  | CreateCursorErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
+export function fromBlobs<
+  const blobs extends readonly Hex[] | readonly ByteArray[],
+  to extends To =
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+>(parameters: FromBlobsParameters<blobs, to>): FromBlobsReturnType<to> {
+  const to =
+    parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes')
+  const blobs = (
+    typeof parameters.blobs[0] === 'string'
+      ? parameters.blobs.map((x) => hexToBytes(x as Hex))
+      : parameters.blobs
+  ) as ByteArray[]
+
+  const length = blobs.reduce((length, blob) => length + blob.length, 0)
+  const data = createCursor(new Uint8Array(length))
+  let active = true
+
+  for (const blob of blobs) {
+    const cursor = createCursor(blob)
+    while (active && cursor.position < blob.length) {
+      // First byte will be a zero 0x00 byte – we can skip.
+      cursor.incrementPosition(1)
+
+      let consume = 31
+      if (blob.length - cursor.position < 31)
+        consume = blob.length - cursor.position
+      const bytes = cursor.readBytes(consume)
+
+      for (const byte of bytes) {
+        if (byte === 0x80) {
+          active = false
+          break
+        }
+        data.pushByte(byte)
+      }
+    }
+  }
+
+  const trimmedData = data.bytes.slice(0, data.position)
+  return (
+    to === 'hex' ? bytesToHex(trimmedData) : trimmedData
+  ) as FromBlobsReturnType<to>
+}

package/utils/blob/sidecarsToVersionedHashes.ts

@@ -0,0 +1,66 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { BlobSidecars } from '../../types/eip4844.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import {
+  type CommitmentToVersionedHashErrorType,
+  commitmentToVersionedHash,
+} from './commitmentToVersionedHash.js'
+
+type To = 'hex' | 'bytes'
+
+export type SidecarsToVersionedHashesParameters<
+  sidecars extends BlobSidecars = BlobSidecars,
+  to extends To | undefined = undefined,
+> = {
+  /** Sidecars from blobs. */
+  sidecars: sidecars | BlobSidecars
+  /** Return type. */
+  to?: to | To | undefined
+  /** Version to tag onto the hashes. */
+  version?: number
+}
+
+export type SidecarsToVersionedHashesReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
+
+export type SidecarsToVersionedHashesErrorType =
+  | CommitmentToVersionedHashErrorType
+  | ErrorType
+
+/**
+ * Transforms a list of sidecars to their versioned hashes.
+ *
+ * @example
+ * ```ts
+ * import { toBlobSidecars, sidecarsToVersionedHashes, stringToHex } from 'viem'
+ *
+ * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+ * const versionedHashes = sidecarsToVersionedHashes({ sidecars })
+ * ```
+ */
+export function sidecarsToVersionedHashes<
+  const sidecars extends BlobSidecars,
+  to extends To =
+    | (sidecars extends BlobSidecars<Hex> ? 'hex' : never)
+    | (sidecars extends BlobSidecars<ByteArray> ? 'bytes' : never),
+>(
+  parameters: SidecarsToVersionedHashesParameters<sidecars, to>,
+): SidecarsToVersionedHashesReturnType<to> {
+  const { sidecars, version } = parameters
+
+  const to =
+    parameters.to ?? (typeof sidecars[0].blob === 'string' ? 'hex' : 'bytes')
+
+  const hashes: Uint8Array[] | Hex[] = []
+  for (const { commitment } of sidecars) {
+    hashes.push(
+      commitmentToVersionedHash({
+        commitment,
+        to,
+        version,
+      }) as any,
+    )
+  }
+  return hashes as SidecarsToVersionedHashesReturnType<to>
+}

package/utils/blob/toBlobSidecars.ts

@@ -0,0 +1,109 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { BlobSidecars } from '../../types/eip4844.js'
+import type { Kzg } from '../../types/kzg.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import type { OneOf } from '../../types/utils.js'
+import {
+  type BlobsToCommitmentsErrorType,
+  blobsToCommitments,
+} from './blobsToCommitments.js'
+import { blobsToProofs, type blobsToProofsErrorType } from './blobsToProofs.js'
+import { type ToBlobsErrorType, toBlobs } from './toBlobs.js'
+
+type To = 'hex' | 'bytes'
+
+export type ToBlobSidecarsParameters<
+  data extends Hex | ByteArray | undefined = undefined,
+  blobs extends Hex[] | ByteArray[] | undefined = undefined,
+  to extends To =
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
+  ///
+  _blobsType =
+    | (blobs extends Hex[] ? Hex[] : never)
+    | (blobs extends ByteArray[] ? ByteArray[] : never),
+> = {
+  /** Return type. */
+  to?: to | To | undefined
+} & OneOf<
+  | {
+      /** Data to transform into blobs. */
+      data: data | Hex | ByteArray
+      /** KZG implementation. */
+      kzg: Kzg
+    }
+  | {
+      /** Blobs. */
+      blobs: blobs | Hex[] | ByteArray[]
+      /** Commitment for each blob. */
+      commitments: _blobsType | Hex[] | ByteArray[]
+      /** Proof for each blob. */
+      proofs: _blobsType | Hex[] | ByteArray[]
+    }
+>
+
+export type ToBlobSidecarsReturnType<to extends To> =
+  | (to extends 'bytes' ? BlobSidecars<ByteArray> : never)
+  | (to extends 'hex' ? BlobSidecars<Hex> : never)
+
+export type ToBlobSidecarsErrorType =
+  | BlobsToCommitmentsErrorType
+  | ToBlobsErrorType
+  | blobsToProofsErrorType
+  | ErrorType
+
+/**
+ * Transforms arbitrary data (or blobs, commitments, & proofs) into a sidecar array.
+ *
+ * @example
+ * ```ts
+ * import { toBlobSidecars, stringToHex } from 'viem'
+ *
+ * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   toBlobs,
+ *   blobsToProofs,
+ *   toBlobSidecars,
+ *   stringToHex
+ * } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const proofs = blobsToProofs({ blobs, commitments, kzg })
+ *
+ * const sidecars = toBlobSidecars({ blobs, commitments, proofs })
+ * ```
+ */
+export function toBlobSidecars<
+  const data extends Hex | ByteArray | undefined = undefined,
+  const blobs extends Hex[] | ByteArray[] | undefined = undefined,
+  to extends To =
+    | (data extends Hex ? 'hex' : never)
+    | (data extends ByteArray ? 'bytes' : never)
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
+>(
+  parameters: ToBlobSidecarsParameters<data, blobs, to>,
+): ToBlobSidecarsReturnType<to> {
+  const { data, kzg, to } = parameters
+  const blobs = parameters.blobs ?? toBlobs({ data: data!, to })
+  const commitments =
+    parameters.commitments ?? blobsToCommitments({ blobs, kzg: kzg!, to })
+  const proofs =
+    parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg: kzg!, to })
+
+  const sidecars: BlobSidecars = []
+  for (let i = 0; i < blobs.length; i++)
+    sidecars.push({
+      blob: blobs[i],
+      commitment: commitments[i],
+      proof: proofs[i],
+    })
+
+  return sidecars as ToBlobSidecarsReturnType<to>
+}

package/utils/blob/toBlobs.ts

@@ -0,0 +1,113 @@
+import {
+  bytesPerBlob,
+  bytesPerFieldElement,
+  fieldElementsPerBlob,
+  maxBytesPerTransaction,
+} from '../../constants/blob.js'
+import {
+  BlobSizeTooLargeError,
+  type BlobSizeTooLargeErrorType,
+  EmptyBlobError,
+  type EmptyBlobErrorType,
+} from '../../errors/blob.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { createCursor } from '../cursor.js'
+import { type SizeErrorType, size } from '../data/size.js'
+import { type HexToBytesErrorType, hexToBytes } from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+
+type To = 'hex' | 'bytes'
+
+export type ToBlobsParameters<
+  data extends Hex | ByteArray = Hex | ByteArray,
+  to extends To | undefined = undefined,
+> = {
+  /** Data to transform to a blob. */
+  data: data | Hex | ByteArray
+  /** Return type. */
+  to?: to | To | undefined
+}
+
+export type ToBlobsReturnType<to extends To> =
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
+
+export type ToBlobsErrorType =
+  | BlobSizeTooLargeErrorType
+  | BytesToHexErrorType
+  | EmptyBlobErrorType
+  | HexToBytesErrorType
+  | SizeErrorType
+  | ErrorType
+
+/**
+ * Transforms arbitrary data to blobs.
+ *
+ * @example
+ * ```ts
+ * import { toBlobs, stringToHex } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * ```
+ */
+export function toBlobs<
+  const data extends Hex | ByteArray,
+  to extends To =
+    | (data extends Hex ? 'hex' : never)
+    | (data extends ByteArray ? 'bytes' : never),
+>(parameters: ToBlobsParameters<data, to>): ToBlobsReturnType<to> {
+  const to =
+    parameters.to ?? (typeof parameters.data === 'string' ? 'hex' : 'bytes')
+  const data = (
+    typeof parameters.data === 'string'
+      ? hexToBytes(parameters.data)
+      : parameters.data
+  ) as ByteArray
+
+  const size_ = size(data)
+  if (!size_) throw new EmptyBlobError()
+  if (size_ > maxBytesPerTransaction)
+    throw new BlobSizeTooLargeError({
+      maxSize: maxBytesPerTransaction,
+      size: size_,
+    })
+
+  const blobs = []
+
+  let active = true
+  let position = 0
+  while (active) {
+    const blob = createCursor(new Uint8Array(bytesPerBlob))
+
+    let size = 0
+    while (size < fieldElementsPerBlob) {
+      const bytes = data.slice(position, position + (bytesPerFieldElement - 1))
+
+      // Push a zero byte so the field element doesn't overflow the BLS modulus.
+      blob.pushByte(0x00)
+
+      // Push the current segment of data bytes.
+      blob.pushBytes(bytes)
+
+      // If we detect that the current segment of data bytes is less than 31 bytes,
+      // we can stop processing and push a terminator byte to indicate the end of the blob.
+      if (bytes.length < 31) {
+        blob.pushByte(0x80)
+        active = false
+        break
+      }
+
+      size++
+      position += 31
+    }
+
+    blobs.push(blob)
+  }
+
+  return (
+    to === 'bytes'
+      ? blobs.map((x) => x.bytes)
+      : blobs.map((x) => bytesToHex(x.bytes))
+  ) as ToBlobsReturnType<to>
+}

package/utils/encoding/toRlp.ts

@@ -10,7 +10,7 @@ import {
 import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
 import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
-export type RecursiveArray<T> = T | RecursiveArray<T>[]
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[]
 
 type To = 'hex' | 'bytes'
 
@@ -64,7 +64,7 @@ function getEncodable(
 ): Encodable {
   if (Array.isArray(bytes))
     return getEncodableList(bytes.map((x) => getEncodable(x)))
-  return getEncodableBytes(bytes)
+  return getEncodableBytes(bytes as any)
 }
 
 function getEncodableList(list: Encodable[]): Encodable {

package/utils/formatters/transaction.ts

@@ -5,8 +5,9 @@ import type {
   ExtractChainFormatterExclude,
   ExtractChainFormatterReturnType,
 } from '../../types/chain.js'
+import type { Hex } from '../../types/misc.js'
 import type { RpcTransaction } from '../../types/rpc.js'
-import type { Transaction } from '../../types/transaction.js'
+import type { Transaction, TransactionType } from '../../types/transaction.js'
 import type { UnionLooseOmit } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
@@ -38,7 +39,7 @@ export const transactionType = {
   '0x1': 'eip2930',
   '0x2': 'eip1559',
   '0x3': 'eip4844',
-} as const
+} as const satisfies Record<Hex, TransactionType>
 
 export type FormatTransactionErrorType = ErrorType
 

package/utils/formatters/transactionRequest.ts

@@ -3,9 +3,10 @@ import type {
   Chain,
   ExtractChainFormatterParameters,
 } from '../../types/chain.js'
+import type { ByteArray } from '../../types/misc.js'
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
-import { numberToHex } from '../encoding/toHex.js'
+import { bytesToHex, numberToHex } from '../encoding/toHex.js'
 import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
@@ -25,40 +26,32 @@ export const rpcTransactionType = {
 
 export type FormatTransactionRequestErrorType = ErrorType
 
-export function formatTransactionRequest(
-  transactionRequest: Partial<TransactionRequest>,
-) {
-  return {
-    ...transactionRequest,
-    gas:
-      typeof transactionRequest.gas !== 'undefined'
-        ? numberToHex(transactionRequest.gas)
-        : undefined,
-    gasPrice:
-      typeof transactionRequest.gasPrice !== 'undefined'
-        ? numberToHex(transactionRequest.gasPrice)
-        : undefined,
-    maxFeePerGas:
-      typeof transactionRequest.maxFeePerGas !== 'undefined'
-        ? numberToHex(transactionRequest.maxFeePerGas)
-        : undefined,
-    maxPriorityFeePerGas:
-      typeof transactionRequest.maxPriorityFeePerGas !== 'undefined'
-        ? numberToHex(transactionRequest.maxPriorityFeePerGas)
-        : undefined,
-    nonce:
-      typeof transactionRequest.nonce !== 'undefined'
-        ? numberToHex(transactionRequest.nonce)
-        : undefined,
-    type:
-      typeof transactionRequest.type !== 'undefined'
-        ? rpcTransactionType[transactionRequest.type]
-        : undefined,
-    value:
-      typeof transactionRequest.value !== 'undefined'
-        ? numberToHex(transactionRequest.value)
-        : undefined,
-  } as RpcTransactionRequest
+export function formatTransactionRequest(request: Partial<TransactionRequest>) {
+  const rpcRequest = { ...request } as RpcTransactionRequest
+
+  if (
+    typeof request.blobs !== 'undefined' &&
+    typeof request.blobs[0] !== 'string'
+  )
+    rpcRequest.blobs = (request.blobs as ByteArray[]).map((x) => bytesToHex(x))
+  if (typeof request.gas !== 'undefined')
+    rpcRequest.gas = numberToHex(request.gas)
+  if (typeof request.gasPrice !== 'undefined')
+    rpcRequest.gasPrice = numberToHex(request.gasPrice)
+  if (typeof request.maxFeePerBlobGas !== 'undefined')
+    rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas)
+  if (typeof request.maxFeePerGas !== 'undefined')
+    rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas)
+  if (typeof request.maxPriorityFeePerGas !== 'undefined')
+    rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas)
+  if (typeof request.nonce !== 'undefined')
+    rpcRequest.nonce = numberToHex(request.nonce)
+  if (typeof request.type !== 'undefined')
+    rpcRequest.type = rpcTransactionType[request.type]
+  if (typeof request.value !== 'undefined')
+    rpcRequest.value = numberToHex(request.value)
+
+  return rpcRequest
 }
 
 export type DefineTransactionRequestErrorType =

package/utils/kzg/defineKzg.ts

@@ -0,0 +1,30 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Kzg } from '../../types/kzg.js'
+
+export type DefineKzgParameters = Kzg
+export type DefineKzgReturnType = Kzg
+export type DefineKzgErrorType = ErrorType
+
+/**
+ * Defines a KZG interface.
+ *
+ * @example
+ * ```ts
+ * import * as cKzg from 'c-kzg'
+ * import { defineKzg } from 'viem'
+ * import { mainnetTrustedSetupPath } from 'viem/node'
+ *
+ * cKzg.loadTrustedSetup(mainnetTrustedSetupPath)
+ *
+ * const kzg = defineKzg(cKzg)
+ * ```
+ */
+export function defineKzg({
+  blobToKzgCommitment,
+  computeBlobKzgProof,
+}: DefineKzgParameters): DefineKzgReturnType {
+  return {
+    blobToKzgCommitment,
+    computeBlobKzgProof,
+  }
+}

package/utils/kzg/setupKzg.ts

@@ -0,0 +1,38 @@
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type DefineKzgErrorType,
+  type DefineKzgParameters,
+  type DefineKzgReturnType,
+  defineKzg,
+} from './defineKzg.js'
+
+export type SetupKzgParameters = DefineKzgParameters & {
+  loadTrustedSetup(path: string): void
+}
+export type SetupKzgReturnType = DefineKzgReturnType
+export type SetupKzgErrorType = DefineKzgErrorType | ErrorType
+
+/**
+ * Sets up and returns a KZG interface.
+ *
+ * @example
+ * ```ts
+ * import * as cKzg from 'c-kzg'
+ * import { setupKzg } from 'viem'
+ * import { mainnetTrustedSetupPath } from 'viem/node'
+ *
+ * const kzg = setupKzg(cKzg, mainnetTrustedSetupPath)
+ * ```
+ */
+export function setupKzg(
+  parameters: SetupKzgParameters,
+  path: string,
+): SetupKzgReturnType {
+  try {
+    parameters.loadTrustedSetup(path)
+  } catch (e) {
+    const error = e as Error
+    if (!error.message.includes('trusted setup is already loaded')) throw error
+  }
+  return defineKzg(parameters)
+}

package/utils/signature/compactSignatureToSignature.ts

@@ -30,8 +30,8 @@ export function compactSignatureToSignature({
   yParityAndS,
 }: CompactSignature): Signature {
   const yParityAndS_bytes = hexToBytes(yParityAndS)
-  const v = yParityAndS_bytes[0] & 0x80 ? 28n : 27n
+  const yParity = yParityAndS_bytes[0] & 0x80 ? 1 : 0
   const s = yParityAndS_bytes
-  if (v === 28n) s[0] &= 0x7f
-  return { r, s: bytesToHex(s), v }
+  if (yParity === 1) s[0] &= 0x7f
+  return { r, s: bytesToHex(s), yParity }
 }

package/utils/signature/hexToSignature.ts

@@ -22,5 +22,10 @@ export type HexToSignatureErrorType = NumberToHexErrorType | ErrorType
 export function hexToSignature(signatureHex: Hex): Signature {
   const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130))
   const v = BigInt(`0x${signatureHex.slice(130)}`)
-  return { r: numberToHex(r, { size: 32 }), s: numberToHex(s, { size: 32 }), v }
+  return {
+    r: numberToHex(r, { size: 32 }),
+    s: numberToHex(s, { size: 32 }),
+    v,
+    yParity: v === 28n ? 1 : 0,
+  }
 }

package/utils/signature/signatureToCompactSignature.ts

@@ -22,7 +22,7 @@ export type SignatureToCompactSignatureErrorType =
  * signatureToCompactSignature({
  *   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
  *   s: '0x7e865ad05c4035ab5792787d4a0297a43617ae897930a6fe4d822b8faea52064',
- *   v: 27n
+ *   yParity: 0
  * })
  * // {
  * //   r: '0x68a020a209d3d56c46f38cc50a33f704f4a9a10a59377f8dd762ac66910e9b90',
@@ -32,10 +32,10 @@ export type SignatureToCompactSignatureErrorType =
 export function signatureToCompactSignature(
   signature: Signature,
 ): CompactSignature {
-  const { r, s, v } = signature
-  const yParity = v - 27n
+  const { r, s, v, yParity } = signature
+  const yParity_ = Number(yParity ?? v! - 27n)
   let yParityAndS = s
-  if (yParity === 1n) {
+  if (yParity_ === 1) {
     const bytes = hexToBytes(s)
     bytes[0] |= 0x80
     yParityAndS = bytesToHex(bytes)