@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fcf8d024ea

package/src/execution/engine/types.ts

@@ -0,0 +1,640 @@
+import {
+  BYTES_PER_FIELD_ELEMENT,
+  BYTES_PER_LOGS_BLOOM,
+  CELLS_PER_EXT_BLOB,
+  CONSOLIDATION_REQUEST_TYPE,
+  DEPOSIT_REQUEST_TYPE,
+  FIELD_ELEMENTS_PER_BLOB,
+  ForkName,
+  ForkSeq,
+  WITHDRAWAL_REQUEST_TYPE,
+} from "@lodestar/params";
+import {
+  BlobsBundle,
+  ExecutionPayload,
+  ExecutionRequests,
+  Root,
+  Wei,
+  bellatrix,
+  capella,
+  deneb,
+  electra,
+  ssz,
+} from "@lodestar/types";
+import {BlobAndProof} from "@lodestar/types/deneb";
+import {BlobAndProofV2} from "@lodestar/types/fulu";
+import {
+  DATA,
+  QUANTITY,
+  bytesToData,
+  dataIntoBytes,
+  dataToBytes,
+  numToQuantity,
+  quantityToBigint,
+  quantityToNum,
+} from "../../eth1/provider/utils.js";
+import {
+  ExecutionPayloadStatus,
+  ExecutionRequestType,
+  PayloadAttributes,
+  VersionedHashes,
+  isExecutionRequestType,
+} from "./interface.js";
+import {WithdrawalV1} from "./payloadIdCache.js";
+
+export type EngineApiRpcParamTypes = {
+  /**
+   * 1. Object - Instance of ExecutionPayload
+   */
+  engine_newPayloadV1: [ExecutionPayloadRpc];
+  engine_newPayloadV2: [ExecutionPayloadRpc];
+  engine_newPayloadV3: [ExecutionPayloadRpc, VersionedHashesRpc, DATA];
+  engine_newPayloadV4: [ExecutionPayloadRpc, VersionedHashesRpc, DATA, ExecutionRequestsRpc];
+  /**
+   * 1. Object - Payload validity status with respect to the consensus rules:
+   *   - blockHash: DATA, 32 Bytes - block hash value of the payload
+   *   - status: String: VALID|INVALID - result of the payload validation with respect to the proof-of-stake consensus rules
+   */
+  engine_forkchoiceUpdatedV1: [
+    forkChoiceData: {headBlockHash: DATA; safeBlockHash: DATA; finalizedBlockHash: DATA},
+    payloadAttributes?: PayloadAttributesRpc,
+  ];
+  engine_forkchoiceUpdatedV2: [
+    forkChoiceData: {headBlockHash: DATA; safeBlockHash: DATA; finalizedBlockHash: DATA},
+    payloadAttributes?: PayloadAttributesRpc,
+  ];
+  engine_forkchoiceUpdatedV3: [
+    forkChoiceData: {headBlockHash: DATA; safeBlockHash: DATA; finalizedBlockHash: DATA},
+    payloadAttributes?: PayloadAttributesRpc,
+  ];
+  /**
+   * 1. payloadId: QUANTITY, 64 Bits - Identifier of the payload building process
+   */
+  engine_getPayloadV1: [QUANTITY];
+  engine_getPayloadV2: [QUANTITY];
+  engine_getPayloadV3: [QUANTITY];
+  engine_getPayloadV4: [QUANTITY];
+  engine_getPayloadV5: [QUANTITY];
+
+  /**
+   * 1. Array of DATA - Array of block_hash field values of the ExecutionPayload structure
+   *  */
+  engine_getPayloadBodiesByHashV1: DATA[][];
+
+  /**
+   *  1. start: QUANTITY, 64 bits - Starting block number
+   *  2. count: QUANTITY, 64 bits - Number of blocks to return
+   */
+  engine_getPayloadBodiesByRangeV1: [start: QUANTITY, count: QUANTITY];
+
+  /**
+   * Object - Instance of ClientVersion
+   */
+  engine_getClientVersionV1: [ClientVersionRpc];
+
+  engine_getBlobsV1: [DATA[]];
+  engine_getBlobsV2: [DATA[]];
+};
+
+export type PayloadStatus = {
+  status: ExecutionPayloadStatus;
+  latestValidHash: DATA | null;
+  validationError: string | null;
+};
+
+export type EngineApiRpcReturnTypes = {
+  /**
+   * Object - Response object:
+   * - status: String - the result of the payload execution:
+   */
+  engine_newPayloadV1: PayloadStatus;
+  engine_newPayloadV2: PayloadStatus;
+  engine_newPayloadV3: PayloadStatus;
+  engine_newPayloadV4: PayloadStatus;
+  engine_forkchoiceUpdatedV1: {
+    payloadStatus: PayloadStatus;
+    payloadId: QUANTITY | null;
+  };
+  engine_forkchoiceUpdatedV2: {
+    payloadStatus: PayloadStatus;
+    payloadId: QUANTITY | null;
+  };
+  engine_forkchoiceUpdatedV3: {
+    payloadStatus: PayloadStatus;
+    payloadId: QUANTITY | null;
+  };
+  /**
+   * payloadId | Error: QUANTITY, 64 Bits - Identifier of the payload building process
+   */
+  engine_getPayloadV1: ExecutionPayloadRpc;
+  engine_getPayloadV2: ExecutionPayloadResponse;
+  engine_getPayloadV3: ExecutionPayloadResponse;
+  engine_getPayloadV4: ExecutionPayloadResponse;
+  engine_getPayloadV5: ExecutionPayloadResponse;
+
+  engine_getPayloadBodiesByHashV1: (ExecutionPayloadBodyRpc | null)[];
+
+  engine_getPayloadBodiesByRangeV1: (ExecutionPayloadBodyRpc | null)[];
+
+  engine_getClientVersionV1: ClientVersionRpc[];
+
+  engine_getBlobsV1: (BlobAndProofRpc | null)[];
+  engine_getBlobsV2: BlobAndProofV2Rpc[] | null;
+};
+
+type ExecutionPayloadRpcWithValue = {
+  executionPayload: ExecutionPayloadRpc;
+  // even though CL tracks this as executionPayloadValue, EL returns this as blockValue
+  blockValue: QUANTITY;
+  blobsBundle?: BlobsBundleRpc;
+  executionRequests?: ExecutionRequestsRpc;
+  shouldOverrideBuilder?: boolean;
+};
+type ExecutionPayloadResponse = ExecutionPayloadRpcWithValue;
+
+export type ExecutionPayloadBodyRpc = {
+  transactions: DATA[];
+  withdrawals: WithdrawalV1[] | null | undefined;
+};
+
+export type ExecutionPayloadBody = {
+  transactions: bellatrix.Transaction[];
+  withdrawals: capella.Withdrawals | null;
+};
+
+export type ExecutionPayloadRpc = {
+  parentHash: DATA; // 32 bytes
+  feeRecipient: DATA; // 20 bytes
+  stateRoot: DATA; // 32 bytes
+  receiptsRoot: DATA; // 32 bytes
+  logsBloom: DATA; // 256 bytes
+  prevRandao: DATA; // 32 bytes
+  blockNumber: QUANTITY;
+  gasLimit: QUANTITY;
+  gasUsed: QUANTITY;
+  timestamp: QUANTITY;
+  extraData: DATA; // 0 to 32 bytes
+  baseFeePerGas: QUANTITY;
+  blockHash: DATA; // 32 bytes
+  transactions: DATA[];
+  withdrawals?: WithdrawalRpc[]; // Capella hardfork
+  blobGasUsed?: QUANTITY; // DENEB
+  excessBlobGas?: QUANTITY; // DENEB
+};
+
+export type WithdrawalRpc = {
+  index: QUANTITY;
+  validatorIndex: QUANTITY;
+  address: DATA;
+  amount: QUANTITY;
+};
+
+/**
+ * ExecutionRequestsRpc only holds at most 3 elements and no repeated type:
+ * - ssz'ed DepositRequests
+ * - ssz'ed WithdrawalRequests
+ * - ssz'ed ConsolidationRequests
+ */
+export type ExecutionRequestsRpc = (DepositRequestsRpc | WithdrawalRequestsRpc | ConsolidationRequestsRpc)[];
+
+export type DepositRequestsRpc = DATA;
+export type WithdrawalRequestsRpc = DATA;
+export type ConsolidationRequestsRpc = DATA;
+
+export type BlobAndProofRpc = {
+  blob: DATA;
+  proof: DATA;
+};
+
+export type BlobAndProofV2Rpc = {
+  blob: DATA;
+  proofs: DATA[];
+};
+
+const BLOB_BYTES = BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB;
+const PROOF_BYTES = 48;
+
+export const BLOB_AND_PROOF_V2_RPC_BYTES = BLOB_BYTES + PROOF_BYTES * CELLS_PER_EXT_BLOB;
+
+export type VersionedHashesRpc = DATA[];
+
+export type PayloadAttributesRpc = {
+  /** QUANTITY, 64 Bits - value for the timestamp field of the new payload */
+  timestamp: QUANTITY;
+  /** DATA, 32 Bytes - value for the prevRandao field of the new payload */
+  prevRandao: DATA;
+  /** DATA, 20 Bytes - suggested value for the coinbase field of the new payload */
+  suggestedFeeRecipient: DATA;
+  withdrawals?: WithdrawalRpc[];
+  /** DATA, 32 Bytes - value for the parentBeaconBlockRoot to be used for building block */
+  parentBeaconBlockRoot?: DATA;
+};
+
+export type ClientVersionRpc = {
+  /** ClientCode */
+  code: string;
+  /** string, Human-readable name of the client */
+  name: string;
+  /** string, the version string of the current implementation */
+  version: string;
+  /** DATA, 4 bytes - first four bytes of the latest commit hash of this build  */
+  commit: DATA;
+};
+
+export interface BlobsBundleRpc {
+  commitments: DATA[]; // each 48 bytes
+  blobs: DATA[]; // each 4096 * 32 = 131072 bytes
+  proofs: DATA[]; // some ELs could also provide proofs, each 48 bytes
+}
+
+export function serializeExecutionPayload(fork: ForkName, data: ExecutionPayload): ExecutionPayloadRpc {
+  const payload: ExecutionPayloadRpc = {
+    parentHash: bytesToData(data.parentHash),
+    feeRecipient: bytesToData(data.feeRecipient),
+    stateRoot: bytesToData(data.stateRoot),
+    receiptsRoot: bytesToData(data.receiptsRoot),
+    logsBloom: bytesToData(data.logsBloom),
+    prevRandao: bytesToData(data.prevRandao),
+    blockNumber: numToQuantity(data.blockNumber),
+    gasLimit: numToQuantity(data.gasLimit),
+    gasUsed: numToQuantity(data.gasUsed),
+    timestamp: numToQuantity(data.timestamp),
+    extraData: bytesToData(data.extraData),
+    baseFeePerGas: numToQuantity(data.baseFeePerGas),
+    blockHash: bytesToData(data.blockHash),
+    transactions: data.transactions.map((tran) => bytesToData(tran)),
+  };
+
+  // Capella adds withdrawals to the ExecutionPayload
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    const {withdrawals} = data as capella.ExecutionPayload;
+    payload.withdrawals = withdrawals.map(serializeWithdrawal);
+  }
+
+  // DENEB adds blobGasUsed & excessBlobGas to the ExecutionPayload
+  if (ForkSeq[fork] >= ForkSeq.deneb) {
+    const {blobGasUsed, excessBlobGas} = data as deneb.ExecutionPayload;
+    payload.blobGasUsed = numToQuantity(blobGasUsed);
+    payload.excessBlobGas = numToQuantity(excessBlobGas);
+  }
+
+  // No changes in Electra
+
+  return payload;
+}
+
+export function serializeVersionedHashes(vHashes: VersionedHashes): VersionedHashesRpc {
+  return vHashes.map(bytesToData);
+}
+
+export function hasPayloadValue(
+  response: ExecutionPayloadResponse | ExecutionPayloadRpc
+): response is ExecutionPayloadRpcWithValue {
+  return (response as ExecutionPayloadRpcWithValue).blockValue !== undefined;
+}
+
+export function parseExecutionPayload(
+  fork: ForkName,
+  response: ExecutionPayloadResponse | ExecutionPayloadRpc
+): {
+  executionPayload: ExecutionPayload;
+  executionPayloadValue: Wei;
+  blobsBundle?: BlobsBundle;
+  executionRequests?: ExecutionRequests;
+  shouldOverrideBuilder?: boolean;
+} {
+  let data: ExecutionPayloadRpc;
+  let executionPayloadValue: Wei;
+  let blobsBundle: BlobsBundle | undefined;
+  let executionRequests: ExecutionRequests | undefined;
+  let shouldOverrideBuilder: boolean;
+
+  if (hasPayloadValue(response)) {
+    executionPayloadValue = quantityToBigint(response.blockValue);
+    data = response.executionPayload;
+    blobsBundle = response.blobsBundle ? parseBlobsBundle(response.blobsBundle) : undefined;
+    executionRequests = response.executionRequests
+      ? deserializeExecutionRequests(response.executionRequests)
+      : undefined;
+    shouldOverrideBuilder = response.shouldOverrideBuilder ?? false;
+  } else {
+    data = response;
+    // Just set it to zero as default
+    executionPayloadValue = BigInt(0);
+    blobsBundle = undefined;
+    executionRequests = undefined;
+    shouldOverrideBuilder = false;
+  }
+
+  const executionPayload = {
+    parentHash: dataToBytes(data.parentHash, 32),
+    feeRecipient: dataToBytes(data.feeRecipient, 20),
+    stateRoot: dataToBytes(data.stateRoot, 32),
+    receiptsRoot: dataToBytes(data.receiptsRoot, 32),
+    logsBloom: dataToBytes(data.logsBloom, BYTES_PER_LOGS_BLOOM),
+    prevRandao: dataToBytes(data.prevRandao, 32),
+    blockNumber: quantityToNum(data.blockNumber),
+    gasLimit: quantityToNum(data.gasLimit),
+    gasUsed: quantityToNum(data.gasUsed),
+    timestamp: quantityToNum(data.timestamp),
+    extraData: dataToBytes(data.extraData, null),
+    baseFeePerGas: quantityToBigint(data.baseFeePerGas),
+    blockHash: dataToBytes(data.blockHash, 32),
+    transactions: data.transactions.map((tran) => dataToBytes(tran, null)),
+  };
+
+  if (ForkSeq[fork] >= ForkSeq.capella) {
+    const {withdrawals} = data;
+    // Geth can also reply with null
+    if (withdrawals == null) {
+      throw Error(
+        `withdrawals missing for ${fork} >= capella executionPayload number=${executionPayload.blockNumber} hash=${data.blockHash}`
+      );
+    }
+    (executionPayload as capella.ExecutionPayload).withdrawals = withdrawals.map((w) => deserializeWithdrawal(w));
+  }
+
+  // DENEB adds excessBlobGas to the ExecutionPayload
+  if (ForkSeq[fork] >= ForkSeq.deneb) {
+    const {blobGasUsed, excessBlobGas} = data;
+
+    if (blobGasUsed == null) {
+      throw Error(
+        `blobGasUsed missing for ${fork} >= deneb executionPayload number=${executionPayload.blockNumber} hash=${data.blockHash}`
+      );
+    }
+    if (excessBlobGas == null) {
+      throw Error(
+        `excessBlobGas missing for ${fork} >= deneb executionPayload number=${executionPayload.blockNumber} hash=${data.blockHash}`
+      );
+    }
+
+    (executionPayload as deneb.ExecutionPayload).blobGasUsed = quantityToBigint(blobGasUsed);
+    (executionPayload as deneb.ExecutionPayload).excessBlobGas = quantityToBigint(excessBlobGas);
+  }
+
+  // No changes in Electra
+
+  return {executionPayload, executionPayloadValue, blobsBundle, executionRequests, shouldOverrideBuilder};
+}
+
+export function serializePayloadAttributes(data: PayloadAttributes): PayloadAttributesRpc {
+  return {
+    timestamp: numToQuantity(data.timestamp),
+    prevRandao: bytesToData(data.prevRandao),
+    suggestedFeeRecipient: data.suggestedFeeRecipient,
+    withdrawals: data.withdrawals?.map(serializeWithdrawal),
+    parentBeaconBlockRoot: data.parentBeaconBlockRoot ? bytesToData(data.parentBeaconBlockRoot) : undefined,
+  };
+}
+
+export function serializeBeaconBlockRoot(data: Root): DATA {
+  return bytesToData(data);
+}
+
+export function deserializePayloadAttributes(data: PayloadAttributesRpc): PayloadAttributes {
+  return {
+    timestamp: quantityToNum(data.timestamp),
+    prevRandao: dataToBytes(data.prevRandao, 32),
+    // DATA is anyway a hex string, so we can just track it as a hex string to
+    // avoid any conversions
+    suggestedFeeRecipient: data.suggestedFeeRecipient,
+    withdrawals: data.withdrawals?.map((withdrawal) => deserializeWithdrawal(withdrawal)),
+    parentBeaconBlockRoot: data.parentBeaconBlockRoot ? dataToBytes(data.parentBeaconBlockRoot, 32) : undefined,
+  };
+}
+
+export function parseBlobsBundle(data: BlobsBundleRpc): BlobsBundle {
+  return {
+    // As of Nov 17th 2022 according to Dan's tests Geth returns null if no blobs in block
+    commitments: (data.commitments ?? []).map((kzg) => dataToBytes(kzg, 48)),
+    blobs: (data.blobs ?? []).map((blob) => dataToBytes(blob, BLOB_BYTES)),
+    proofs: (data.proofs ?? []).map((kzg) => dataToBytes(kzg, PROOF_BYTES)),
+  };
+}
+
+export function serializeBlobsBundle(data: BlobsBundle): BlobsBundleRpc {
+  return {
+    commitments: data.commitments.map((kzg) => bytesToData(kzg)),
+    blobs: data.blobs.map((blob) => bytesToData(blob)),
+    proofs: data.proofs.map((proof) => bytesToData(proof)),
+  };
+}
+
+export function serializeWithdrawal(withdrawal: capella.Withdrawal): WithdrawalRpc {
+  return {
+    index: numToQuantity(withdrawal.index),
+    validatorIndex: numToQuantity(withdrawal.validatorIndex),
+    address: bytesToData(withdrawal.address),
+    // Both CL and EL now deal in Gwei, just little-endian to big-endian conversion required
+    amount: numToQuantity(withdrawal.amount),
+  };
+}
+
+export function deserializeWithdrawal(serialized: WithdrawalRpc): capella.Withdrawal {
+  return {
+    index: quantityToNum(serialized.index),
+    validatorIndex: quantityToNum(serialized.validatorIndex),
+    address: dataToBytes(serialized.address, 20),
+    // Both CL and EL now deal in Gwei, just big-endian to little-endian conversion required
+    amount: quantityToBigint(serialized.amount),
+  } as capella.Withdrawal;
+}
+
+/**
+ * Prepend a single-byte requestType to requestsBytes
+ */
+function prefixRequests(requestsBytes: Uint8Array, requestType: ExecutionRequestType): Uint8Array {
+  const prefixedRequests = new Uint8Array(1 + requestsBytes.length);
+  prefixedRequests[0] = requestType;
+  prefixedRequests.set(requestsBytes, 1);
+
+  return prefixedRequests;
+}
+
+function serializeDepositRequests(depositRequests: electra.DepositRequests): DepositRequestsRpc {
+  const requestsBytes = ssz.electra.DepositRequests.serialize(depositRequests);
+  return bytesToData(prefixRequests(requestsBytes, DEPOSIT_REQUEST_TYPE));
+}
+
+function deserializeDepositRequests(serialized: DepositRequestsRpc): electra.DepositRequests {
+  return ssz.electra.DepositRequests.deserialize(dataToBytes(serialized, null));
+}
+
+function serializeWithdrawalRequests(withdrawalRequests: electra.WithdrawalRequests): WithdrawalRequestsRpc {
+  const requestsBytes = ssz.electra.WithdrawalRequests.serialize(withdrawalRequests);
+  return bytesToData(prefixRequests(requestsBytes, WITHDRAWAL_REQUEST_TYPE));
+}
+
+function deserializeWithdrawalRequests(serialized: WithdrawalRequestsRpc): electra.WithdrawalRequests {
+  return ssz.electra.WithdrawalRequests.deserialize(dataToBytes(serialized, null));
+}
+
+function serializeConsolidationRequests(
+  consolidationRequests: electra.ConsolidationRequests
+): ConsolidationRequestsRpc {
+  const requestsBytes = ssz.electra.ConsolidationRequests.serialize(consolidationRequests);
+  return bytesToData(prefixRequests(requestsBytes, CONSOLIDATION_REQUEST_TYPE));
+}
+
+function deserializeConsolidationRequests(serialized: ConsolidationRequestsRpc): electra.ConsolidationRequests {
+  return ssz.electra.ConsolidationRequests.deserialize(dataToBytes(serialized, null));
+}
+
+/**
+ * This is identical to get_execution_requests_list in
+ * https://github.com/ethereum/consensus-specs/blob/v1.5.0-alpha.8/specs/electra/beacon-chain.md#new-get_execution_requests_list
+ */
+export function serializeExecutionRequests(executionRequests: ExecutionRequests): ExecutionRequestsRpc {
+  const {deposits, withdrawals, consolidations} = executionRequests;
+  const result = [];
+
+  if (deposits.length !== 0) {
+    result.push(serializeDepositRequests(deposits));
+  }
+
+  if (withdrawals.length !== 0) {
+    result.push(serializeWithdrawalRequests(withdrawals));
+  }
+
+  if (consolidations.length !== 0) {
+    result.push(serializeConsolidationRequests(consolidations));
+  }
+
+  return result;
+}
+
+export function deserializeExecutionRequests(serialized: ExecutionRequestsRpc): ExecutionRequests {
+  const result: ExecutionRequests = {
+    deposits: [],
+    withdrawals: [],
+    consolidations: [],
+  };
+
+  if (serialized.length === 0) {
+    return result;
+  }
+
+  let prevRequestType: ExecutionRequestType | undefined;
+
+  for (let prefixedRequests of serialized) {
+    // Slice out 0x so it is easier to extract request type
+    if (prefixedRequests.startsWith("0x")) {
+      prefixedRequests = prefixedRequests.slice(2);
+    }
+
+    const currentRequestType = parseInt(prefixedRequests.substring(0, 2), 16);
+
+    if (!isExecutionRequestType(currentRequestType)) {
+      throw Error(`Invalid request type currentRequestType=${prefixedRequests.substring(0, 2)}`);
+    }
+
+    const requests = prefixedRequests.slice(2);
+
+    if (requests.length === 0) {
+      throw Error(
+        `Request with empty data must be excluded from execution requests currentRequestType=${currentRequestType}`
+      );
+    }
+
+    if (prevRequestType !== undefined && prevRequestType >= currentRequestType) {
+      throw Error(
+        `Current request type must be larger than previous request type prevRequestType=${prevRequestType} currentRequestType=${currentRequestType}`
+      );
+    }
+
+    switch (currentRequestType) {
+      case DEPOSIT_REQUEST_TYPE: {
+        result.deposits = deserializeDepositRequests(requests);
+        break;
+      }
+      case WITHDRAWAL_REQUEST_TYPE: {
+        result.withdrawals = deserializeWithdrawalRequests(requests);
+        break;
+      }
+      case CONSOLIDATION_REQUEST_TYPE: {
+        result.consolidations = deserializeConsolidationRequests(requests);
+        break;
+      }
+    }
+    prevRequestType = currentRequestType;
+  }
+
+  return result;
+}
+
+export function deserializeExecutionPayloadBody(data: ExecutionPayloadBodyRpc | null): ExecutionPayloadBody | null {
+  return data
+    ? {
+        transactions: data.transactions.map((tran) => dataToBytes(tran, null)),
+        withdrawals: data.withdrawals ? data.withdrawals.map(deserializeWithdrawal) : null,
+      }
+    : null;
+}
+
+export function serializeExecutionPayloadBody(data: ExecutionPayloadBody | null): ExecutionPayloadBodyRpc | null {
+  return data
+    ? {
+        transactions: data.transactions.map((tran) => bytesToData(tran)),
+        withdrawals: data.withdrawals ? data.withdrawals.map(serializeWithdrawal) : null,
+      }
+    : null;
+}
+
+export function deserializeBlobAndProofs(data: BlobAndProofRpc | null): BlobAndProof | null {
+  return data
+    ? {
+        blob: dataToBytes(data.blob, BLOB_BYTES),
+        proof: dataToBytes(data.proof, PROOF_BYTES),
+      }
+    : null;
+}
+
+export function deserializeBlobAndProofsV2(data: BlobAndProofV2Rpc): BlobAndProofV2 {
+  return {
+    blob: dataToBytes(data.blob, BLOB_BYTES),
+    proofs: data.proofs.map((proof) => dataToBytes(proof, PROOF_BYTES)),
+  };
+}
+
+/**
+ * The same to deserializeBlobAndProofsV2 but using preallocated buffers since BlobAndProofV2Rpc is fixed size
+ */
+export function deserializeBlobAndProofsV2IntoBytes(data: BlobAndProofV2Rpc, buffer: Uint8Array): BlobAndProofV2 {
+  if (buffer.length !== BLOB_AND_PROOF_V2_RPC_BYTES) {
+    throw Error(
+      `Invalid buffer length ${buffer.length}, expected ${BLOB_AND_PROOF_V2_RPC_BYTES} to hold BlobAndProofV2Rpc`
+    );
+  }
+
+  // https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#blobandproofv2
+  // proofs MUST contain exactly CELLS_PER_EXT_BLOB cell proofs.
+  if (data.proofs.length !== CELLS_PER_EXT_BLOB) {
+    throw Error(`Invalid proofs length ${data.proofs.length}, expected ${CELLS_PER_EXT_BLOB}`);
+  }
+
+  const blob = dataIntoBytes(data.blob, buffer.subarray(0, BLOB_BYTES));
+  const proofs: Uint8Array[] = [];
+  for (let i = 0; i < CELLS_PER_EXT_BLOB; i++) {
+    const proof = dataIntoBytes(
+      data.proofs[i],
+      buffer.subarray(BLOB_BYTES + i * PROOF_BYTES, BLOB_BYTES + (i + 1) * PROOF_BYTES)
+    );
+    if (proof.length !== PROOF_BYTES) {
+      throw Error(`Invalid proof length ${proof.length}, expected ${PROOF_BYTES}`);
+    }
+    proofs.push(proof);
+  }
+
+  return {
+    blob,
+    proofs,
+  };
+}
+
+export function assertReqSizeLimit(blockHashesReqCount: number, count: number): void {
+  if (blockHashesReqCount > count) {
+    throw new Error(`Requested blocks must not be > ${count}`);
+  }
+  return;
+}