viem 0.0.0-main.20240408T061242 → 0.0.0-main.20240408T210957

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;AAS5C,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;AAS5C,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"}

package/actions/index.ts

@@ -343,7 +343,6 @@ export {
   type PrepareTransactionRequestParameters,
   type PrepareTransactionRequestReturnType,
   prepareTransactionRequest,
-  defaultParameters as defaultPrepareTransactionRequestParameters,
 } from './wallet/prepareTransactionRequest.js'
 export {
   type SendTransactionErrorType,

package/actions/public/estimateGas.ts

@@ -107,7 +107,6 @@ export async function estimateGas<
     const {
       accessList,
       blobs,
-      blobVersionedHashes,
       blockNumber,
       blockTag,
       data,
@@ -120,13 +119,13 @@ export async function estimateGas<
       to,
       value,
       ...rest
-    } = (await prepareTransactionRequest(client, {
-      ...args,
-      parameters:
-        // Some RPC Providers do not compute versioned hashes from blobs. We will need
-        // to compute them.
-        account?.type === 'json-rpc' ? ['blobVersionedHashes'] : undefined,
-    } as PrepareTransactionRequestParameters)) as EstimateGasParameters
+    } =
+      account?.type === 'local'
+        ? ((await prepareTransactionRequest(
+            client,
+            args as PrepareTransactionRequestParameters,
+          )) as EstimateGasParameters)
+        : args
 
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
     const block = blockNumberHex || blockTag
@@ -142,7 +141,6 @@ export async function estimateGas<
       from: account?.address,
       accessList,
       blobs,
-      blobVersionedHashes,
       data,
       gas,
       gasPrice,

package/actions/wallet/prepareTransactionRequest.ts

@@ -15,7 +15,7 @@ import {
 } from '../../actions/public/estimateGas.js'
 import {
   type GetBlockErrorType,
-  getBlock as getBlock_,
+  getBlock,
 } from '../../actions/public/getBlock.js'
 import {
   type GetTransactionCountErrorType,
@@ -28,8 +28,8 @@ import {
   Eip1559FeesNotSupportedError,
   MaxFeePerGasTooLowError,
 } from '../../errors/fee.js'
+import type { Block, GetTransactionType } from '../../index.js'
 import type { DeriveAccount, GetAccountParameter } from '../../types/account.js'
-import type { Block } from '../../types/block.js'
 import type { Chain, DeriveChain } from '../../types/chain.js'
 import type { GetChainParameter } from '../../types/chain.js'
 import type { GetTransactionRequestKzgParameter } from '../../types/kzg.js'
@@ -48,39 +48,21 @@ import type {
   UnionOmit,
   UnionRequiredBy,
 } from '../../types/utils.js'
-import { blobsToCommitments } from '../../utils/blob/blobsToCommitments.js'
-import { blobsToProofs } from '../../utils/blob/blobsToProofs.js'
-import { commitmentsToVersionedHashes } from '../../utils/blob/commitmentsToVersionedHashes.js'
-import { toBlobSidecars } from '../../utils/blob/toBlobSidecars.js'
 import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import { getAction } from '../../utils/getAction.js'
-import {
-  type AssertRequestErrorType,
-  type AssertRequestParameters,
-  assertRequest,
+import type {
+  AssertRequestErrorType,
+  AssertRequestParameters,
 } from '../../utils/transaction/assertRequest.js'
-import {
-  type GetTransactionType,
-  getTransactionType,
-} from '../../utils/transaction/getTransactionType.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
 import { getChainId } from '../public/getChainId.js'
 
-export const defaultParameters = [
-  'blobVersionedHashes',
-  'chainId',
-  'fees',
-  'gas',
-  'nonce',
-  'type',
-] as const
-
 export type PrepareTransactionRequestParameterType =
-  | 'blobVersionedHashes'
   | 'chainId'
   | 'fees'
   | 'gas'
   | 'nonce'
-  | 'sidecars'
   | 'type'
 type ParameterTypeToParameters<
   parameterType extends PrepareTransactionRequestParameterType,
@@ -95,7 +77,7 @@ export type PrepareTransactionRequestRequest<
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'> &
   GetTransactionRequestKzgParameter & {
-    parameters?: readonly PrepareTransactionRequestParameterType[] | undefined
+    parameters?: PrepareTransactionRequestParameterType[] | undefined
   }
 
 export type PrepareTransactionRequestParameters<
@@ -153,7 +135,7 @@ export type PrepareTransactionRequestReturnType<
     accountOverride
   >,
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
-  _transactionType = request['type'] extends string | undefined
+  _transactionType = request['type'] extends string
     ? request['type']
     : GetTransactionType<request> extends 'legacy'
       ? unknown
@@ -178,9 +160,9 @@ export type PrepareTransactionRequestReturnType<
         : ExactPartial<_transactionRequest>
     > & { chainId?: number | undefined },
     ParameterTypeToParameters<
-      request['parameters'] extends readonly PrepareTransactionRequestParameterType[]
+      request['parameters'] extends PrepareTransactionRequestParameterType[]
         ? request['parameters'][number]
-        : (typeof defaultParameters)[number]
+        : PrepareTransactionRequestParameterType
     >
   > &
     (unknown extends request['kzg'] ? {} : Pick<request, 'kzg'>)
@@ -261,57 +243,17 @@ export async function prepareTransactionRequest<
 > {
   const {
     account: account_ = client.account,
-    blobs,
     chain,
     chainId,
     gas,
-    kzg,
     nonce,
-    parameters = defaultParameters,
+    parameters = ['chainId', 'fees', 'gas', 'nonce', 'type'],
     type,
   } = args
   const account = account_ ? parseAccount(account_) : undefined
 
   const request = { ...args, ...(account ? { from: account?.address } : {}) }
 
-  let block: Block | undefined
-  async function getBlock(): Promise<Block> {
-    if (block) return block
-    block = await getAction(
-      client,
-      getBlock_,
-      'getBlock',
-    )({ blockTag: 'latest' })
-    return block
-  }
-
-  if (
-    (parameters.includes('blobVersionedHashes') ||
-      parameters.includes('sidecars')) &&
-    blobs &&
-    kzg
-  ) {
-    const commitments = blobsToCommitments({ blobs, kzg })
-
-    if (parameters.includes('blobVersionedHashes')) {
-      const versionedHashes = commitmentsToVersionedHashes({
-        commitments,
-        to: 'hex',
-      })
-      request.blobVersionedHashes = versionedHashes
-    }
-    if (parameters.includes('sidecars')) {
-      const proofs = blobsToProofs({ blobs, commitments, kzg })
-      const sidecars = toBlobSidecars({
-        blobs,
-        commitments,
-        proofs,
-        to: 'hex',
-      })
-      request.sidecars = sidecars
-    }
-  }
-
   if (parameters.includes('chainId')) {
     if (chain) request.chainId = chain.id
     else if (typeof chainId !== 'undefined') request.chainId = chainId
@@ -328,6 +270,11 @@ export async function prepareTransactionRequest<
       blockTag: 'pending',
     })
 
+  const block = await (() => {
+    if (typeof request.type !== 'undefined') return
+    return getAction(client, getBlock, 'getBlock')({ blockTag: 'latest' })
+  })()
+
   if (
     (parameters.includes('fees') || parameters.includes('type')) &&
     typeof type === 'undefined'
@@ -338,7 +285,6 @@ export async function prepareTransactionRequest<
       ) as any
     } catch {
       // infer type from block
-      const block = await getBlock()
       request.type =
         typeof block?.baseFeePerGas === 'bigint' ? 'eip1559' : 'legacy'
     }
@@ -353,7 +299,6 @@ export async function prepareTransactionRequest<
         typeof request.maxFeePerGas === 'undefined' ||
         typeof request.maxPriorityFeePerGas === 'undefined'
       ) {
-        const block = await getBlock()
         const { maxFeePerGas, maxPriorityFeePerGas } =
           await internal_estimateFeesPerGas(client, {
             block: block as Block,
@@ -381,7 +326,6 @@ export async function prepareTransactionRequest<
       )
         throw new Eip1559FeesNotSupportedError()
 
-      const block = await getBlock()
       const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(
         client,
         {

package/actions/wallet/sendTransaction.ts

@@ -39,7 +39,6 @@ import {
 import { type GetChainIdErrorType, getChainId } from '../public/getChainId.js'
 import {
   type PrepareTransactionRequestErrorType,
-  defaultParameters,
   prepareTransactionRequest,
 } from './prepareTransactionRequest.js'
 import {
@@ -191,7 +190,6 @@ export async function sendTransaction<
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
-        parameters: [...defaultParameters, 'sidecars'],
         to,
         value,
         ...rest,

package/chains/definitions/filecoinCalibration.ts

@@ -17,4 +17,5 @@ export const filecoinCalibration = /*#__PURE__*/ defineChain({
       url: 'https://calibration.filscan.io',
     },
   },
+  testnet: true,
 })

package/chains/definitions/filecoinHyperspace.ts

@@ -17,4 +17,5 @@ export const filecoinHyperspace = /*#__PURE__*/ defineChain({
       url: 'https://hyperspace.filfox.info/en',
     },
   },
+  testnet: true,
 })

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.0.0-main.20240408T061242'
+export const version = '0.0.0-main.20240408T210957'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "0.0.0-main.20240408T061242",
+  "version": "0.0.0-main.20240408T210957",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/types/transaction.ts

@@ -227,17 +227,7 @@ export type TransactionRequestEIP4844<
     /** The blobs associated with this transaction. */
     blobs: readonly Hex[] | readonly ByteArray[]
     type?: TTransactionType | undefined
-  } & OneOf<
-    | { kzg: Kzg | undefined }
-    | {
-        blobVersionedHashes: readonly Hex[]
-        kzg?: Kzg | undefined
-      }
-    | {
-        kzg?: Kzg | undefined
-        sidecars: readonly BlobSidecar<Hex>[]
-      }
-  >
+  }
 export type TransactionRequest<TQuantity = bigint, TIndex = number> = OneOf<
   | TransactionRequestLegacy<TQuantity, TIndex>
   | TransactionRequestEIP2930<TQuantity, TIndex>
@@ -245,20 +235,6 @@ export type TransactionRequest<TQuantity = bigint, TIndex = number> = OneOf<
   | TransactionRequestEIP4844<TQuantity, TIndex>
 >
 
-export type TransactionRequestGeneric<
-  TQuantity = bigint,
-  TIndex = number,
-> = TransactionRequestBase<TQuantity, TIndex> & {
-  accessList?: AccessList | undefined
-  blobs?: readonly Hex[] | readonly ByteArray[] | undefined
-  blobVersionedHashes?: readonly Hex[] | undefined
-  gasPrice?: TQuantity | undefined
-  maxFeePerBlobGas?: TQuantity | undefined
-  maxFeePerGas?: TQuantity | undefined
-  maxPriorityFeePerGas?: TQuantity | undefined
-  type?: string | undefined
-}
-
 export type TransactionSerializedEIP1559 = `0x02${string}`
 export type TransactionSerializedEIP2930 = `0x01${string}`
 export type TransactionSerializedEIP4844 = `0x03${string}`
@@ -324,18 +300,17 @@ export type TransactionSerializableEIP4844<
   ExactPartial<FeeValuesEIP4844<TQuantity>> & {
     accessList?: AccessList | undefined
     chainId: number
-    sidecars?: readonly BlobSidecar<Hex>[] | false | undefined
     type?: 'eip4844' | undefined
     yParity?: number | undefined
   } & OneOf<
     | {
-        blobs?: readonly Hex[] | readonly ByteArray[] | undefined
         blobVersionedHashes: readonly Hex[]
+        sidecars?: readonly BlobSidecar<Hex>[] | false | undefined
       }
     | {
         blobs: readonly Hex[] | readonly ByteArray[]
-        blobVersionedHashes?: readonly Hex[] | undefined
         kzg: Kzg
+        sidecars?: false | undefined
       }
   >
 

package/utils/blob/blobsToCommitments.ts

@@ -7,13 +7,11 @@ import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
 type To = 'hex' | 'bytes'
 
 export type BlobsToCommitmentsParameters<
-  blobs extends readonly ByteArray[] | readonly Hex[] =
-    | readonly ByteArray[]
-    | readonly Hex[],
+  blobs extends ByteArray[] | Hex[] = ByteArray[] | Hex[],
   to extends To | undefined = undefined,
 > = {
   /** Blobs to transform into commitments. */
-  blobs: blobs | readonly ByteArray[] | readonly Hex[]
+  blobs: blobs | ByteArray[] | Hex[]
   /** KZG implementation. */
   kzg: Pick<Kzg, 'blobToKzgCommitment'>
   /** Return type. */
@@ -21,8 +19,8 @@ export type BlobsToCommitmentsParameters<
 }
 
 export type BlobsToCommitmentsReturnType<to extends To> =
-  | (to extends 'bytes' ? readonly ByteArray[] : never)
-  | (to extends 'hex' ? readonly Hex[] : never)
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
 
 export type BlobsToCommitmentsErrorType =
   | HexToBytesErrorType
@@ -42,10 +40,10 @@ export type BlobsToCommitmentsErrorType =
  * ```
  */
 export function blobsToCommitments<
-  const blobs extends readonly ByteArray[] | readonly Hex[],
+  const blobs extends ByteArray[] | Hex[],
   to extends To =
-    | (blobs extends readonly Hex[] ? 'hex' : never)
-    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
 >(
   parameters: BlobsToCommitmentsParameters<blobs, to>,
 ): BlobsToCommitmentsReturnType<to> {

package/utils/blob/blobsToProofs.ts

@@ -7,15 +7,15 @@ import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
 type To = 'hex' | 'bytes'
 
 export type blobsToProofsParameters<
-  blobs extends readonly ByteArray[] | readonly Hex[],
-  commitments extends readonly ByteArray[] | readonly Hex[],
+  blobs extends ByteArray[] | Hex[],
+  commitments extends ByteArray[] | Hex[],
   to extends To =
-    | (blobs extends readonly Hex[] ? 'hex' : never)
-    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
   ///
   _blobsType =
-    | (blobs extends readonly Hex[] ? readonly Hex[] : never)
-    | (blobs extends readonly ByteArray[] ? readonly ByteArray[] : never),
+    | (blobs extends Hex[] ? Hex[] : never)
+    | (blobs extends ByteArray[] ? ByteArray[] : never),
 > = {
   /** Blobs to transform into proofs. */
   blobs: blobs
@@ -56,11 +56,11 @@ export type blobsToProofsErrorType =
  * ```
  */
 export function blobsToProofs<
-  const blobs extends readonly ByteArray[] | readonly Hex[],
-  const commitments extends readonly ByteArray[] | readonly Hex[],
+  const blobs extends ByteArray[] | Hex[],
+  const commitments extends ByteArray[] | Hex[],
   to extends To =
-    | (blobs extends readonly Hex[] ? 'hex' : never)
-    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
 >(
   parameters: blobsToProofsParameters<blobs, commitments, to>,
 ): blobsToProofsReturnType<to> {

package/utils/blob/commitmentsToVersionedHashes.ts

@@ -8,13 +8,11 @@ import {
 type To = 'hex' | 'bytes'
 
 export type CommitmentsToVersionedHashesParameters<
-  commitments extends readonly Uint8Array[] | readonly Hex[] =
-    | readonly Uint8Array[]
-    | readonly Hex[],
+  commitments extends Uint8Array[] | Hex[] = Uint8Array[] | Hex[],
   to extends To | undefined = undefined,
 > = {
   /** Commitments from blobs. */
-  commitments: commitments | readonly Uint8Array[] | readonly Hex[]
+  commitments: commitments | Uint8Array[] | Hex[]
   /** Return type. */
   to?: to | To | undefined
   /** Version to tag onto the hashes. */
@@ -22,8 +20,8 @@ export type CommitmentsToVersionedHashesParameters<
 }
 
 export type CommitmentsToVersionedHashesReturnType<to extends To> =
-  | (to extends 'bytes' ? readonly ByteArray[] : never)
-  | (to extends 'hex' ? readonly Hex[] : never)
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
 
 export type CommitmentsToVersionedHashesErrorType =
   | CommitmentToVersionedHashErrorType
@@ -47,10 +45,10 @@ export type CommitmentsToVersionedHashesErrorType =
  * ```
  */
 export function commitmentsToVersionedHashes<
-  const commitments extends readonly Uint8Array[] | readonly Hex[],
+  const commitments extends Uint8Array[] | Hex[],
   to extends To =
-    | (commitments extends readonly Hex[] ? 'hex' : never)
-    | (commitments extends readonly ByteArray[] ? 'bytes' : never),
+    | (commitments extends Hex[] ? 'hex' : never)
+    | (commitments extends ByteArray[] ? 'bytes' : never),
 >(
   parameters: CommitmentsToVersionedHashesParameters<commitments, to>,
 ): CommitmentsToVersionedHashesReturnType<to> {
@@ -69,5 +67,5 @@ export function commitmentsToVersionedHashes<
       }) as any,
     )
   }
-  return hashes as any
+  return hashes as CommitmentsToVersionedHashesReturnType<to>
 }

package/utils/blob/sidecarsToVersionedHashes.ts

@@ -21,8 +21,8 @@ export type SidecarsToVersionedHashesParameters<
 }
 
 export type SidecarsToVersionedHashesReturnType<to extends To> =
-  | (to extends 'bytes' ? readonly ByteArray[] : never)
-  | (to extends 'hex' ? readonly Hex[] : never)
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
 
 export type SidecarsToVersionedHashesErrorType =
   | CommitmentToVersionedHashErrorType
@@ -62,5 +62,5 @@ export function sidecarsToVersionedHashes<
       }) as any,
     )
   }
-  return hashes as any
+  return hashes as SidecarsToVersionedHashesReturnType<to>
 }

package/utils/blob/toBlobSidecars.ts

@@ -14,14 +14,14 @@ type To = 'hex' | 'bytes'
 
 export type ToBlobSidecarsParameters<
   data extends Hex | ByteArray | undefined = undefined,
-  blobs extends readonly Hex[] | readonly ByteArray[] | undefined = undefined,
+  blobs extends Hex[] | ByteArray[] | undefined = undefined,
   to extends To =
-    | (blobs extends readonly Hex[] ? 'hex' : never)
-    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
   ///
   _blobsType =
-    | (blobs extends readonly Hex[] ? readonly Hex[] : never)
-    | (blobs extends readonly ByteArray[] ? readonly ByteArray[] : never),
+    | (blobs extends Hex[] ? Hex[] : never)
+    | (blobs extends ByteArray[] ? ByteArray[] : never),
 > = {
   /** Return type. */
   to?: to | To | undefined
@@ -34,11 +34,11 @@ export type ToBlobSidecarsParameters<
     }
   | {
       /** Blobs. */
-      blobs: blobs | readonly Hex[] | readonly ByteArray[]
+      blobs: blobs | Hex[] | ByteArray[]
       /** Commitment for each blob. */
-      commitments: _blobsType | readonly Hex[] | readonly ByteArray[]
+      commitments: _blobsType | Hex[] | ByteArray[]
       /** Proof for each blob. */
-      proofs: _blobsType | readonly Hex[] | readonly ByteArray[]
+      proofs: _blobsType | Hex[] | ByteArray[]
     }
 >
 
@@ -81,15 +81,12 @@ export type ToBlobSidecarsErrorType =
  */
 export function toBlobSidecars<
   const data extends Hex | ByteArray | undefined = undefined,
-  const blobs extends
-    | readonly Hex[]
-    | readonly 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 readonly Hex[] ? 'hex' : never)
-    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
+    | (blobs extends Hex[] ? 'hex' : never)
+    | (blobs extends ByteArray[] ? 'bytes' : never),
 >(
   parameters: ToBlobSidecarsParameters<data, blobs, to>,
 ): ToBlobSidecarsReturnType<to> {

package/utils/blob/toBlobs.ts

@@ -30,8 +30,8 @@ export type ToBlobsParameters<
 }
 
 export type ToBlobsReturnType<to extends To> =
-  | (to extends 'bytes' ? readonly ByteArray[] : never)
-  | (to extends 'hex' ? readonly Hex[] : never)
+  | (to extends 'bytes' ? ByteArray[] : never)
+  | (to extends 'hex' ? Hex[] : never)
 
 export type ToBlobsErrorType =
   | BlobSizeTooLargeErrorType
@@ -109,5 +109,5 @@ export function toBlobs<
     to === 'bytes'
       ? blobs.map((x) => x.bytes)
       : blobs.map((x) => bytesToHex(x.bytes))
-  ) as any
+  ) as ToBlobsReturnType<to>
 }

package/utils/formatters/transactionRequest.ts

@@ -34,8 +34,6 @@ export function formatTransactionRequest(
 
   if (typeof request.accessList !== 'undefined')
     rpcRequest.accessList = request.accessList
-  if (typeof request.blobVersionedHashes !== 'undefined')
-    rpcRequest.blobVersionedHashes = request.blobVersionedHashes
   if (typeof request.blobs !== 'undefined') {
     if (typeof request.blobs[0] !== 'string')
       rpcRequest.blobs = (request.blobs as ByteArray[]).map((x) =>

package/utils/transaction/getTransactionType.ts

@@ -9,10 +9,10 @@ import type {
   FeeValuesLegacy,
 } from '../../index.js'
 import type {
+  TransactionRequest,
   TransactionRequestEIP1559,
   TransactionRequestEIP2930,
   TransactionRequestEIP4844,
-  TransactionRequestGeneric,
   TransactionRequestLegacy,
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
@@ -79,7 +79,7 @@ type EIP4844Properties = Assign<
 
 export type GetTransactionType<
   transaction extends OneOf<
-    TransactionSerializableGeneric | TransactionRequestGeneric
+    TransactionSerializableGeneric | TransactionRequest
   > = TransactionSerializableGeneric,
   result =
     | (transaction extends
@@ -115,7 +115,7 @@ export type GetTransationTypeErrorType =
 
 export function getTransactionType<
   const transaction extends OneOf<
-    TransactionSerializableGeneric | TransactionRequestGeneric
+    TransactionSerializableGeneric | TransactionRequest
   >,
 >(transaction: transaction): GetTransactionType<transaction> {
   if (transaction.type)

package/utils/transaction/serializeTransaction.ts

@@ -157,11 +157,7 @@ function serializeTransactionEIP4844(
   let blobVersionedHashes = transaction.blobVersionedHashes
   let sidecars = transaction.sidecars
   // If `blobs` are passed, we will need to compute the KZG commitments & proofs.
-  if (
-    transaction.blobs &&
-    (typeof blobVersionedHashes === 'undefined' ||
-      typeof sidecars === 'undefined')
-  ) {
+  if (transaction.blobs) {
     const blobs = (
       typeof transaction.blobs[0] === 'string'
         ? transaction.blobs
@@ -172,15 +168,13 @@ function serializeTransactionEIP4844(
       blobs,
       kzg,
     })
+    const proofs = blobsToProofs({ blobs, commitments, kzg })
+    blobVersionedHashes = commitmentsToVersionedHashes({
+      commitments,
+    })
 
-    if (typeof blobVersionedHashes === 'undefined')
-      blobVersionedHashes = commitmentsToVersionedHashes({
-        commitments,
-      })
-    if (typeof sidecars === 'undefined') {
-      const proofs = blobsToProofs({ blobs, commitments, kzg })
+    if (sidecars !== false)
       sidecars = toBlobSidecars({ blobs, commitments, proofs })
-    }
   }
 
   const serializedAccessList = serializeAccessList(accessList)