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

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

package/actions/public/estimateGas.ts

@@ -107,6 +107,7 @@ export async function estimateGas<
     const {
       accessList,
       blobs,
+      blobVersionedHashes,
       blockNumber,
       blockTag,
       data,
@@ -119,13 +120,13 @@ export async function estimateGas<
       to,
       value,
       ...rest
-    } =
-      account?.type === 'local'
-        ? ((await prepareTransactionRequest(
-            client,
-            args as PrepareTransactionRequestParameters,
-          )) as EstimateGasParameters)
-        : args
+    } = (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
 
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
     const block = blockNumberHex || blockTag
@@ -141,6 +142,7 @@ 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,
+  getBlock as 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,21 +48,39 @@ 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,
-  AssertRequestParameters,
+import {
+  type AssertRequestErrorType,
+  type AssertRequestParameters,
+  assertRequest,
 } from '../../utils/transaction/assertRequest.js'
-import { assertRequest } from '../../utils/transaction/assertRequest.js'
-import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
+import {
+  type GetTransactionType,
+  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,
@@ -77,7 +95,7 @@ export type PrepareTransactionRequestRequest<
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'> &
   GetTransactionRequestKzgParameter & {
-    parameters?: PrepareTransactionRequestParameterType[] | undefined
+    parameters?: readonly PrepareTransactionRequestParameterType[] | undefined
   }
 
 export type PrepareTransactionRequestParameters<
@@ -135,7 +153,7 @@ export type PrepareTransactionRequestReturnType<
     accountOverride
   >,
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
-  _transactionType = request['type'] extends string
+  _transactionType = request['type'] extends string | undefined
     ? request['type']
     : GetTransactionType<request> extends 'legacy'
       ? unknown
@@ -160,9 +178,9 @@ export type PrepareTransactionRequestReturnType<
         : ExactPartial<_transactionRequest>
     > & { chainId?: number | undefined },
     ParameterTypeToParameters<
-      request['parameters'] extends PrepareTransactionRequestParameterType[]
+      request['parameters'] extends readonly PrepareTransactionRequestParameterType[]
         ? request['parameters'][number]
-        : PrepareTransactionRequestParameterType
+        : (typeof defaultParameters)[number]
     >
   > &
     (unknown extends request['kzg'] ? {} : Pick<request, 'kzg'>)
@@ -243,17 +261,57 @@ export async function prepareTransactionRequest<
 > {
   const {
     account: account_ = client.account,
+    blobs,
     chain,
     chainId,
     gas,
+    kzg,
     nonce,
-    parameters = ['chainId', 'fees', 'gas', 'nonce', 'type'],
+    parameters = defaultParameters,
     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
@@ -270,11 +328,6 @@ 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'
@@ -285,6 +338,7 @@ export async function prepareTransactionRequest<
       ) as any
     } catch {
       // infer type from block
+      const block = await getBlock()
       request.type =
         typeof block?.baseFeePerGas === 'bigint' ? 'eip1559' : 'legacy'
     }
@@ -299,6 +353,7 @@ 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,
@@ -326,6 +381,7 @@ export async function prepareTransactionRequest<
       )
         throw new Eip1559FeesNotSupportedError()
 
+      const block = await getBlock()
       const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(
         client,
         {

package/actions/wallet/sendTransaction.ts

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

package/errors/version.ts

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

package/package.json

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

package/types/transaction.ts

@@ -227,7 +227,17 @@ 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>
@@ -235,6 +245,20 @@ 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}`
@@ -300,17 +324,18 @@ 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,11 +7,13 @@ import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
 type To = 'hex' | 'bytes'
 
 export type BlobsToCommitmentsParameters<
-  blobs extends ByteArray[] | Hex[] = ByteArray[] | Hex[],
+  blobs extends readonly ByteArray[] | readonly Hex[] =
+    | readonly ByteArray[]
+    | readonly Hex[],
   to extends To | undefined = undefined,
 > = {
   /** Blobs to transform into commitments. */
-  blobs: blobs | ByteArray[] | Hex[]
+  blobs: blobs | readonly ByteArray[] | readonly Hex[]
   /** KZG implementation. */
   kzg: Pick<Kzg, 'blobToKzgCommitment'>
   /** Return type. */
@@ -19,8 +21,8 @@ export type BlobsToCommitmentsParameters<
 }
 
 export type BlobsToCommitmentsReturnType<to extends To> =
-  | (to extends 'bytes' ? ByteArray[] : never)
-  | (to extends 'hex' ? Hex[] : never)
+  | (to extends 'bytes' ? readonly ByteArray[] : never)
+  | (to extends 'hex' ? readonly Hex[] : never)
 
 export type BlobsToCommitmentsErrorType =
   | HexToBytesErrorType
@@ -40,10 +42,10 @@ export type BlobsToCommitmentsErrorType =
  * ```
  */
 export function blobsToCommitments<
-  const blobs extends ByteArray[] | Hex[],
+  const blobs extends readonly ByteArray[] | readonly Hex[],
   to extends To =
-    | (blobs extends Hex[] ? 'hex' : never)
-    | (blobs extends ByteArray[] ? 'bytes' : never),
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly 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 ByteArray[] | Hex[],
-  commitments extends ByteArray[] | Hex[],
+  blobs extends readonly ByteArray[] | readonly Hex[],
+  commitments extends readonly ByteArray[] | readonly Hex[],
   to extends To =
-    | (blobs extends Hex[] ? 'hex' : never)
-    | (blobs extends ByteArray[] ? 'bytes' : never),
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
   ///
   _blobsType =
-    | (blobs extends Hex[] ? Hex[] : never)
-    | (blobs extends ByteArray[] ? ByteArray[] : never),
+    | (blobs extends readonly Hex[] ? readonly Hex[] : never)
+    | (blobs extends readonly ByteArray[] ? readonly ByteArray[] : never),
 > = {
   /** Blobs to transform into proofs. */
   blobs: blobs
@@ -56,11 +56,11 @@ export type blobsToProofsErrorType =
  * ```
  */
 export function blobsToProofs<
-  const blobs extends ByteArray[] | Hex[],
-  const commitments extends ByteArray[] | Hex[],
+  const blobs extends readonly ByteArray[] | readonly Hex[],
+  const commitments extends readonly ByteArray[] | readonly Hex[],
   to extends To =
-    | (blobs extends Hex[] ? 'hex' : never)
-    | (blobs extends ByteArray[] ? 'bytes' : never),
+    | (blobs extends readonly Hex[] ? 'hex' : never)
+    | (blobs extends readonly ByteArray[] ? 'bytes' : never),
 >(
   parameters: blobsToProofsParameters<blobs, commitments, to>,
 ): blobsToProofsReturnType<to> {

package/utils/blob/commitmentsToVersionedHashes.ts

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

package/utils/blob/sidecarsToVersionedHashes.ts

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

package/utils/blob/toBlobSidecars.ts

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

package/utils/formatters/transactionRequest.ts

@@ -34,6 +34,8 @@ 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 | TransactionRequest
+    TransactionSerializableGeneric | TransactionRequestGeneric
   > = TransactionSerializableGeneric,
   result =
     | (transaction extends
@@ -115,7 +115,7 @@ export type GetTransationTypeErrorType =
 
 export function getTransactionType<
   const transaction extends OneOf<
-    TransactionSerializableGeneric | TransactionRequest
+    TransactionSerializableGeneric | TransactionRequestGeneric
   >,
 >(transaction: transaction): GetTransactionType<transaction> {
   if (transaction.type)

package/utils/transaction/serializeTransaction.ts

@@ -157,7 +157,11 @@ 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) {
+  if (
+    transaction.blobs &&
+    (typeof blobVersionedHashes === 'undefined' ||
+      typeof sidecars === 'undefined')
+  ) {
     const blobs = (
       typeof transaction.blobs[0] === 'string'
         ? transaction.blobs
@@ -168,13 +172,15 @@ function serializeTransactionEIP4844(
       blobs,
       kzg,
     })
-    const proofs = blobsToProofs({ blobs, commitments, kzg })
-    blobVersionedHashes = commitmentsToVersionedHashes({
-      commitments,
-    })
 
-    if (sidecars !== false)
+    if (typeof blobVersionedHashes === 'undefined')
+      blobVersionedHashes = commitmentsToVersionedHashes({
+        commitments,
+      })
+    if (typeof sidecars === 'undefined') {
+      const proofs = blobsToProofs({ blobs, commitments, kzg })
       sidecars = toBlobSidecars({ blobs, commitments, proofs })
+    }
   }
 
   const serializedAccessList = serializeAccessList(accessList)