viem 2.7.20 → 2.8.0

package/utils/signature/signatureToHex.ts

@@ -6,7 +6,7 @@ import {
   type HexToBigIntErrorType,
   hexToBigInt,
 } from '../../utils/encoding/fromHex.js'
-import { type ToHexErrorType, toHex } from '../../utils/encoding/toHex.js'
+import { type ToHexErrorType } from '../../utils/encoding/toHex.js'
 
 export type SignatureToHexErrorType =
   | HexToBigIntErrorType
@@ -23,13 +23,18 @@ export type SignatureToHexErrorType =
  * signatureToHex({
  *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
  *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
- *   v: 28n
+ *   yParity: 1
  * })
  * // "0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c"
  */
-export function signatureToHex({ r, s, v }: Signature): Hex {
+export function signatureToHex({ r, s, v, yParity }: Signature): Hex {
+  const vHex = (() => {
+    if (v === 27n || yParity === 0) return '1b'
+    if (v === 28n || yParity === 1) return '1c'
+    throw new Error('Invalid v value')
+  })()
   return `0x${new secp256k1.Signature(
     hexToBigInt(r),
     hexToBigInt(s),
-  ).toCompactHex()}${toHex(v).slice(2)}`
+  ).toCompactHex()}${vHex}`
 }

package/utils/transaction/assertTransaction.ts

@@ -1,8 +1,17 @@
+import { versionedHashVersionKzg } from '../../constants/kzg.js'
 import {
   InvalidAddressError,
   type InvalidAddressErrorType,
 } from '../../errors/address.js'
 import { BaseError, type BaseErrorType } from '../../errors/base.js'
+import {
+  EmptyBlobError,
+  type EmptyBlobErrorType,
+  InvalidVersionedHashSizeError,
+  type InvalidVersionedHashSizeErrorType,
+  InvalidVersionedHashVersionError,
+  type InvalidVersionedHashVersionErrorType,
+} from '../../errors/blob.js'
 import {
   InvalidChainIdError,
   type InvalidChainIdErrorType,
@@ -17,9 +26,41 @@ import type { ErrorType } from '../../errors/utils.js'
 import type {
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
+  TransactionSerializableEIP4844,
   TransactionSerializableLegacy,
 } from '../../types/transaction.js'
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+import { size } from '../data/size.js'
+import { slice } from '../data/slice.js'
+import { hexToNumber } from '../encoding/fromHex.js'
+
+export type AssertTransactionEIP4844ErrorType =
+  | AssertTransactionEIP1559ErrorType
+  | EmptyBlobErrorType
+  | InvalidVersionedHashSizeErrorType
+  | InvalidVersionedHashVersionErrorType
+  | ErrorType
+
+export function assertTransactionEIP4844(
+  transaction: TransactionSerializableEIP4844,
+) {
+  const { blobVersionedHashes } = transaction
+  if (blobVersionedHashes) {
+    if (blobVersionedHashes.length === 0) throw new EmptyBlobError()
+    for (const hash of blobVersionedHashes) {
+      const size_ = size(hash)
+      const version = hexToNumber(slice(hash, 0, 1))
+      if (size_ !== 32)
+        throw new InvalidVersionedHashSizeError({ hash, size: size_ })
+      if (version !== versionedHashVersionKzg)
+        throw new InvalidVersionedHashVersionError({
+          hash,
+          version,
+        })
+    }
+  }
+  assertTransactionEIP1559(transaction as {} as TransactionSerializableEIP1559)
+}
 
 export type AssertTransactionEIP1559ErrorType =
   | BaseErrorType

package/utils/transaction/getSerializedTransactionType.ts

@@ -3,21 +3,41 @@ import {
   type InvalidSerializedTransactionTypeErrorType,
 } from '../../errors/transaction.js'
 import type { ErrorType } from '../../errors/utils.js'
+import type { Hex } from '../../index.js'
 import type {
   TransactionSerialized,
   TransactionSerializedEIP1559,
   TransactionSerializedEIP2930,
+  TransactionSerializedEIP4844,
+  TransactionSerializedGeneric,
+  TransactionSerializedLegacy,
+  TransactionType,
 } from '../../types/transaction.js'
+import type { IsNarrowable, IsNever } from '../../types/utils.js'
 import { type SliceHexErrorType, sliceHex } from '../data/slice.js'
 import { type HexToNumberErrorType, hexToNumber } from '../encoding/fromHex.js'
 
 export type GetSerializedTransactionType<
-  TTransactionSerialized extends TransactionSerialized = TransactionSerialized,
-> = TTransactionSerialized extends TransactionSerializedEIP1559
-  ? 'eip1559'
-  : TTransactionSerialized extends TransactionSerializedEIP2930
-    ? 'eip2930'
+  serializedTransaction extends
+    TransactionSerializedGeneric = TransactionSerialized,
+  result =
+    | (serializedTransaction extends TransactionSerializedEIP1559
+        ? 'eip1559'
+        : never)
+    | (serializedTransaction extends TransactionSerializedEIP2930
+        ? 'eip2930'
+        : never)
+    | (serializedTransaction extends TransactionSerializedEIP4844
+        ? 'eip4844'
+        : never)
+    | (serializedTransaction extends TransactionSerializedLegacy
+        ? 'legacy'
+        : never),
+> = IsNarrowable<serializedTransaction, Hex> extends true
+  ? IsNever<result> extends false
+    ? result
     : 'legacy'
+  : TransactionType
 
 export type GetSerializedTransactionTypeErrorType =
   | HexToNumberErrorType
@@ -26,20 +46,23 @@ export type GetSerializedTransactionTypeErrorType =
   | ErrorType
 
 export function getSerializedTransactionType<
-  TSerialized extends TransactionSerialized,
+  const serializedTransaction extends TransactionSerializedGeneric,
 >(
-  serializedTransaction: TSerialized,
-): GetSerializedTransactionType<TSerialized> {
+  serializedTransaction: serializedTransaction,
+): GetSerializedTransactionType<serializedTransaction> {
   const serializedType = sliceHex(serializedTransaction, 0, 1)
 
+  if (serializedType === '0x03')
+    return 'eip4844' as GetSerializedTransactionType<serializedTransaction>
+
   if (serializedType === '0x02')
-    return 'eip1559' as GetSerializedTransactionType<TSerialized>
+    return 'eip1559' as GetSerializedTransactionType<serializedTransaction>
 
   if (serializedType === '0x01')
-    return 'eip2930' as GetSerializedTransactionType<TSerialized>
+    return 'eip2930' as GetSerializedTransactionType<serializedTransaction>
 
   if (serializedType !== '0x' && hexToNumber(serializedType) >= 0xc0)
-    return 'legacy' as GetSerializedTransactionType<TSerialized>
+    return 'legacy' as GetSerializedTransactionType<serializedTransaction>
 
   throw new InvalidSerializedTransactionTypeError({ serializedType })
 }

package/utils/transaction/getTransactionType.ts

@@ -4,52 +4,135 @@ import {
 } from '../../errors/transaction.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type {
-  TransactionSerializable,
+  FeeValuesEIP1559,
+  FeeValuesEIP4844,
+  FeeValuesLegacy,
+} from '../../index.js'
+import type {
+  TransactionRequest,
+  TransactionRequestEIP1559,
+  TransactionRequestEIP2930,
+  TransactionRequestEIP4844,
+  TransactionRequestLegacy,
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
+  TransactionSerializableEIP4844,
   TransactionSerializableGeneric,
   TransactionSerializableLegacy,
 } from '../../types/transaction.js'
+import type { Assign, IsNever, OneOf, Opaque } from '../../types/utils.js'
+
+type BaseProperties = {
+  accessList?: undefined
+  blobs?: undefined
+  blobVersionedHashes?: undefined
+  gasPrice?: undefined
+  maxFeePerBlobGas?: undefined
+  maxFeePerGas?: undefined
+  maxPriorityFeePerGas?: undefined
+  sidecars?: undefined
+}
+
+type LegacyProperties = Assign<BaseProperties, FeeValuesLegacy>
+type EIP1559Properties = Assign<
+  BaseProperties,
+  OneOf<
+    | {
+        maxFeePerGas: FeeValuesEIP1559['maxFeePerGas']
+      }
+    | {
+        maxPriorityFeePerGas: FeeValuesEIP1559['maxPriorityFeePerGas']
+      },
+    FeeValuesEIP1559
+  > & {
+    accessList?: TransactionSerializableEIP2930['accessList']
+  }
+>
+type EIP2930Properties = Assign<
+  BaseProperties,
+  Partial<FeeValuesLegacy> & {
+    accessList: TransactionSerializableEIP2930['accessList']
+  }
+>
+type EIP4844Properties = Assign<
+  BaseProperties,
+  Partial<FeeValuesEIP4844> &
+    OneOf<
+      | {
+          blobs: TransactionSerializableEIP4844['blobs']
+        }
+      | {
+          blobVersionedHashes: TransactionSerializableEIP4844['blobVersionedHashes']
+        }
+      | {
+          sidecars: TransactionSerializableEIP4844['sidecars']
+        },
+      TransactionSerializableEIP4844
+    >
+>
 
 export type GetTransactionType<
-  TTransactionSerializable extends
-    TransactionSerializable = TransactionSerializable,
-> =
-  | (TTransactionSerializable extends TransactionSerializableLegacy
-      ? 'legacy'
-      : never)
-  | (TTransactionSerializable extends TransactionSerializableEIP1559
-      ? 'eip1559'
-      : never)
-  | (TTransactionSerializable extends TransactionSerializableEIP2930
-      ? 'eip2930'
-      : never)
-  | (TTransactionSerializable extends TransactionSerializableGeneric
-      ? TTransactionSerializable['type']
-      : never)
+  transaction extends OneOf<
+    TransactionSerializableGeneric | TransactionRequest
+  > = TransactionSerializableGeneric,
+  result =
+    | (transaction extends
+        | Opaque<TransactionSerializableLegacy, transaction>
+        | Opaque<TransactionRequestLegacy, transaction>
+        | LegacyProperties
+        ? 'legacy'
+        : never)
+    | (transaction extends
+        | Opaque<TransactionSerializableEIP1559, transaction>
+        | Opaque<TransactionRequestEIP1559, transaction>
+        | EIP1559Properties
+        ? 'eip1559'
+        : never)
+    | (transaction extends
+        | Opaque<TransactionSerializableEIP2930, transaction>
+        | Opaque<TransactionRequestEIP2930, transaction>
+        | EIP2930Properties
+        ? 'eip2930'
+        : never)
+    | (transaction extends
+        | Opaque<TransactionSerializableEIP4844, transaction>
+        | Opaque<TransactionRequestEIP4844, transaction>
+        | EIP4844Properties
+        ? 'eip4844'
+        : never)
+    | (transaction['type'] extends string ? transaction['type'] : never),
+> = IsNever<result> extends false ? result : string
 
 export type GetTransationTypeErrorType =
   | InvalidSerializableTransactionErrorType
   | ErrorType
 
 export function getTransactionType<
-  TTransactionSerializable extends TransactionSerializable,
->(
-  transaction: TTransactionSerializable,
-): GetTransactionType<TTransactionSerializable> {
+  const transaction extends OneOf<
+    TransactionSerializableGeneric | TransactionRequest
+  >,
+>(transaction: transaction): GetTransactionType<transaction> {
   if (transaction.type)
-    return transaction.type as GetTransactionType<TTransactionSerializable>
+    return transaction.type as GetTransactionType<transaction>
+
+  if (
+    typeof transaction.blobs !== 'undefined' ||
+    typeof transaction.blobVersionedHashes !== 'undefined' ||
+    typeof transaction.maxFeePerBlobGas !== 'undefined' ||
+    typeof transaction.sidecars !== 'undefined'
+  )
+    return 'eip4844' as any
 
   if (
     typeof transaction.maxFeePerGas !== 'undefined' ||
     typeof transaction.maxPriorityFeePerGas !== 'undefined'
-  )
-    return 'eip1559' as GetTransactionType<TTransactionSerializable>
+  ) {
+    return 'eip1559' as any
+  }
 
   if (typeof transaction.gasPrice !== 'undefined') {
-    if (typeof transaction.accessList !== 'undefined')
-      return 'eip2930' as GetTransactionType<TTransactionSerializable>
-    return 'legacy' as GetTransactionType<TTransactionSerializable>
+    if (typeof transaction.accessList !== 'undefined') return 'eip2930' as any
+    return 'legacy' as any
   }
 
   throw new InvalidSerializableTransactionError({ transaction })

package/utils/transaction/parseTransaction.ts

@@ -14,15 +14,21 @@ import type {
   AccessList,
   TransactionRequestEIP2930,
   TransactionRequestLegacy,
+  TransactionSerializable,
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
+  TransactionSerializableEIP4844,
   TransactionSerializableLegacy,
   TransactionSerialized,
   TransactionSerializedEIP1559,
   TransactionSerializedEIP2930,
+  TransactionSerializedEIP4844,
+  TransactionSerializedGeneric,
   TransactionType,
 } from '../../types/transaction.js'
+import type { IsNarrowable } from '../../types/utils.js'
 import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+import { toBlobSidecars } from '../blob/toBlobSidecars.js'
 import { type IsHexErrorType, isHex } from '../data/isHex.js'
 import { type PadHexErrorType, padHex } from '../data/pad.js'
 import { trim } from '../data/trim.js'
@@ -39,9 +45,11 @@ import { isHash } from '../hash/isHash.js'
 import {
   type AssertTransactionEIP1559ErrorType,
   type AssertTransactionEIP2930ErrorType,
+  type AssertTransactionEIP4844ErrorType,
   type AssertTransactionLegacyErrorType,
   assertTransactionEIP1559,
   assertTransactionEIP2930,
+  assertTransactionEIP4844,
   assertTransactionLegacy,
 } from './assertTransaction.js'
 import {
@@ -51,22 +59,26 @@ import {
 } from './getSerializedTransactionType.js'
 
 export type ParseTransactionReturnType<
-  TSerialized extends TransactionSerialized = TransactionSerialized,
+  TSerialized extends TransactionSerializedGeneric = TransactionSerialized,
   TType extends TransactionType = GetSerializedTransactionType<TSerialized>,
-> =
-  | (TType extends 'eip1559' ? TransactionSerializableEIP1559 : never)
-  | (TType extends 'eip2930' ? TransactionSerializableEIP2930 : never)
-  | (TType extends 'legacy' ? TransactionSerializableLegacy : never)
+> = IsNarrowable<TSerialized, Hex> extends true
+  ?
+      | (TType extends 'eip1559' ? TransactionSerializableEIP1559 : never)
+      | (TType extends 'eip2930' ? TransactionSerializableEIP2930 : never)
+      | (TType extends 'eip4844' ? TransactionSerializableEIP4844 : never)
+      | (TType extends 'legacy' ? TransactionSerializableLegacy : never)
+  : TransactionSerializable
 
 export type ParseTransactionErrorType =
   | GetSerializedTransactionTypeErrorType
   | ParseTransactionEIP1559ErrorType
   | ParseTransactionEIP2930ErrorType
+  | ParseTransactionEIP4844ErrorType
   | ParseTransactionLegacyErrorType
 
-export function parseTransaction<TSerialized extends TransactionSerialized>(
-  serializedTransaction: TSerialized,
-): ParseTransactionReturnType<TSerialized> {
+export function parseTransaction<
+  const TSerialized extends TransactionSerializedGeneric,
+>(serializedTransaction: TSerialized): ParseTransactionReturnType<TSerialized> {
   const type = getSerializedTransactionType(serializedTransaction)
 
   if (type === 'eip1559')
@@ -79,11 +91,118 @@ export function parseTransaction<TSerialized extends TransactionSerialized>(
       serializedTransaction as TransactionSerializedEIP2930,
     ) as ParseTransactionReturnType<TSerialized>
 
+  if (type === 'eip4844')
+    return parseTransactionEIP4844(
+      serializedTransaction as TransactionSerializedEIP4844,
+    ) as ParseTransactionReturnType<TSerialized>
+
   return parseTransactionLegacy(
     serializedTransaction,
   ) as ParseTransactionReturnType<TSerialized>
 }
 
+type ParseTransactionEIP4844ErrorType =
+  | AssertTransactionEIP4844ErrorType
+  | ToTransactionArrayErrorType
+  | HexToBigIntErrorType
+  | HexToNumberErrorType
+  | InvalidLegacyVErrorType
+  | InvalidSerializedTransactionErrorType
+  | IsHexErrorType
+  | ParseEIP155SignatureErrorType
+  | ErrorType
+
+function parseTransactionEIP4844(
+  serializedTransaction: TransactionSerializedEIP4844,
+): TransactionSerializableEIP4844 {
+  const transactionOrWrapperArray = toTransactionArray(serializedTransaction)
+
+  const hasNetworkWrapper = transactionOrWrapperArray.length === 4
+
+  const transactionArray = hasNetworkWrapper
+    ? transactionOrWrapperArray[0]
+    : transactionOrWrapperArray
+  const wrapperArray = hasNetworkWrapper
+    ? transactionOrWrapperArray.slice(1)
+    : []
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    to,
+    value,
+    data,
+    accessList,
+    maxFeePerBlobGas,
+    blobVersionedHashes,
+    v,
+    r,
+    s,
+  ] = transactionArray
+  const [blobs, commitments, proofs] = wrapperArray
+
+  if (!(transactionArray.length === 11 || transactionArray.length === 14))
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        ...(transactionArray.length > 9
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'eip4844',
+    })
+
+  const transaction = {
+    blobVersionedHashes: blobVersionedHashes as Hex[],
+    chainId: hexToNumber(chainId as Hex),
+    type: 'eip4844',
+  } as TransactionSerializableEIP4844
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(maxFeePerBlobGas) && maxFeePerBlobGas !== '0x')
+    transaction.maxFeePerBlobGas = hexToBigInt(maxFeePerBlobGas)
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+  if (blobs && commitments && proofs)
+    transaction.sidecars = toBlobSidecars({
+      blobs: blobs as Hex[],
+      commitments: commitments as Hex[],
+      proofs: proofs as Hex[],
+    })
+
+  assertTransactionEIP4844(transaction)
+
+  const signature =
+    transactionArray.length === 14
+      ? parseEIP155Signature(transactionArray as RecursiveArray<Hex>)
+      : undefined
+
+  return { ...signature, ...transaction }
+}
+
 type ParseTransactionEIP1559ErrorType =
   | AssertTransactionEIP1559ErrorType
   | ToTransactionArrayErrorType
@@ -303,6 +422,7 @@ function parseTransactionLegacy(
   if (chainId > 0) transaction.chainId = chainId
   else if (v !== 27n && v !== 28n) throw new InvalidLegacyVError({ v })
 
+  delete transaction.yParity
   transaction.v = v
   transaction.s = s as Hex
   transaction.r = r as Hex

package/utils/transaction/serializeAccessList.ts

@@ -32,7 +32,7 @@ export function serializeAccessList(
 ): RecursiveArray<Hex> {
   if (!accessList || accessList.length === 0) return []
 
-  const serializedAccessList: RecursiveArray<Hex> = []
+  const serializedAccessList = []
   for (let i = 0; i < accessList.length; i++) {
     const { address, storageKeys } = accessList[i]