@lodestar/types 1.35.0-dev.e9dd48f165 → 1.35.0-dev.f45a2be721

package/src/deneb/sszTypes.ts

@@ -0,0 +1,329 @@
+import {ByteVectorType, ContainerType, ListCompositeType, VectorCompositeType} from "@chainsafe/ssz";
+import {
+  BYTES_PER_FIELD_ELEMENT,
+  EPOCHS_PER_SYNC_COMMITTEE_PERIOD,
+  FIELD_ELEMENTS_PER_BLOB,
+  HISTORICAL_ROOTS_LIMIT,
+  KZG_COMMITMENT_INCLUSION_PROOF_DEPTH,
+  MAX_BLOB_COMMITMENTS_PER_BLOCK,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {ssz as altairSsz} from "../altair/index.js";
+import {ssz as bellatrixSsz} from "../bellatrix/index.js";
+import {ssz as capellaSsz} from "../capella/index.js";
+import {ssz as phase0Ssz} from "../phase0/index.js";
+import {ssz as primitiveSsz} from "../primitive/index.js";
+
+const {UintNum64, Slot, Root, BLSSignature, UintBn64, UintBn256, Bytes32, Bytes48, Bytes96, BLSPubkey, BlobIndex} =
+  primitiveSsz;
+
+// Polynomial commitments
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/polynomial-commitments.md
+
+// Custom types
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/polynomial-commitments.md#custom-types
+export const G1Point = Bytes48;
+export const G2Point = Bytes96;
+export const BLSFieldElement = Bytes32;
+export const KZGCommitment = Bytes48;
+export const KZGProof = Bytes48;
+
+// Beacon chain
+
+// Custom types
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/beacon-chain.md#custom-types
+
+export const Blob = new ByteVectorType(BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB);
+export const Blobs = new ListCompositeType(Blob, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+export const BlindedBlob = Bytes32;
+export const BlindedBlobs = new ListCompositeType(BlindedBlob, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+
+export const VersionedHash = Bytes32;
+export const BlobKzgCommitments = new ListCompositeType(KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+export const KZGProofs = new ListCompositeType(KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+
+// ReqResp types
+// =============
+
+export const BlobSidecarsByRangeRequest = new ContainerType(
+  {
+    startSlot: Slot,
+    count: UintNum64,
+  },
+  {typeName: "BlobSidecarsByRangeRequest", jsonCase: "eth2"}
+);
+
+export const BlobIdentifier = new ContainerType(
+  {
+    blockRoot: Root,
+    index: BlobIndex,
+  },
+  {typeName: "BlobIdentifier", jsonCase: "eth2"}
+);
+
+// Beacon Chain types
+// https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/beacon-chain.md#containers
+
+export const ExecutionPayload = new ContainerType(
+  {
+    ...capellaSsz.ExecutionPayload.fields,
+    blobGasUsed: UintBn64, // New in DENEB
+    excessBlobGas: UintBn64, // New in DENEB
+  },
+  {typeName: "ExecutionPayload", jsonCase: "eth2"}
+);
+
+export const ExecutionPayloadHeader = new ContainerType(
+  {
+    ...capellaSsz.ExecutionPayloadHeader.fields,
+    blobGasUsed: UintBn64, // New in DENEB
+    excessBlobGas: UintBn64, // New in DENEB
+  },
+  {typeName: "ExecutionPayloadHeader", jsonCase: "eth2"}
+);
+
+// We have to preserve Fields ordering while changing the type of ExecutionPayload
+export const BeaconBlockBody = new ContainerType(
+  {
+    ...altairSsz.BeaconBlockBody.fields,
+    executionPayload: ExecutionPayload, // Modified in DENEB
+    blsToExecutionChanges: capellaSsz.BeaconBlockBody.fields.blsToExecutionChanges,
+    blobKzgCommitments: BlobKzgCommitments, // New in DENEB
+  },
+  {typeName: "BeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BeaconBlock = new ContainerType(
+  {
+    ...capellaSsz.BeaconBlock.fields,
+    body: BeaconBlockBody, // Modified in DENEB
+  },
+  {typeName: "BeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBeaconBlock = new ContainerType(
+  {
+    message: BeaconBlock, // Modified in DENEB
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const KzgCommitmentInclusionProof = new VectorCompositeType(Bytes32, KZG_COMMITMENT_INCLUSION_PROOF_DEPTH);
+
+export const BlobSidecar = new ContainerType(
+  {
+    index: BlobIndex,
+    blob: Blob,
+    kzgCommitment: KZGCommitment,
+    kzgProof: KZGProof,
+    signedBlockHeader: phase0Ssz.SignedBeaconBlockHeader,
+    kzgCommitmentInclusionProof: KzgCommitmentInclusionProof,
+  },
+  {typeName: "BlobSidecar", jsonCase: "eth2"}
+);
+
+export const BlobSidecars = new ListCompositeType(BlobSidecar, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+
+export const BlobsBundle = new ContainerType(
+  {
+    commitments: BlobKzgCommitments,
+    proofs: KZGProofs,
+    blobs: Blobs,
+  },
+  {typeName: "BlobsBundle", jsonCase: "eth2"}
+);
+
+export const BlindedBeaconBlockBody = new ContainerType(
+  {
+    ...altairSsz.BeaconBlockBody.fields,
+    executionPayloadHeader: ExecutionPayloadHeader, // Modified in DENEB
+    blsToExecutionChanges: capellaSsz.BeaconBlockBody.fields.blsToExecutionChanges,
+    blobKzgCommitments: BlobKzgCommitments, // New in DENEB
+  },
+  {typeName: "BlindedBeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BlindedBeaconBlock = new ContainerType(
+  {
+    ...capellaSsz.BlindedBeaconBlock.fields,
+    body: BlindedBeaconBlockBody, // Modified in DENEB
+  },
+  {typeName: "BlindedBeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBlindedBeaconBlock = new ContainerType(
+  {
+    message: BlindedBeaconBlock, // Modified in DENEB
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBlindedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BuilderBid = new ContainerType(
+  {
+    header: ExecutionPayloadHeader,
+    blobKzgCommitments: BlobKzgCommitments,
+    value: UintBn256,
+    pubkey: BLSPubkey,
+  },
+  {typeName: "BuilderBid", jsonCase: "eth2"}
+);
+
+export const SignedBuilderBid = new ContainerType(
+  {
+    message: BuilderBid,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBuilderBid", jsonCase: "eth2"}
+);
+
+export const ExecutionPayloadAndBlobsBundle = new ContainerType(
+  {
+    executionPayload: ExecutionPayload,
+    blobsBundle: BlobsBundle,
+  },
+  {typeName: "ExecutionPayloadAndBlobsBundle", jsonCase: "eth2"}
+);
+
+// We don't spread capella.BeaconState fields since we need to replace
+// latestExecutionPayloadHeader and we cannot keep order doing that
+export const BeaconState = new ContainerType(
+  {
+    genesisTime: UintNum64,
+    genesisValidatorsRoot: Root,
+    slot: primitiveSsz.Slot,
+    fork: phase0Ssz.Fork,
+    // History
+    latestBlockHeader: phase0Ssz.BeaconBlockHeader,
+    blockRoots: phase0Ssz.HistoricalBlockRoots,
+    stateRoots: phase0Ssz.HistoricalStateRoots,
+    // historical_roots Frozen in Capella, replaced by historical_summaries
+    historicalRoots: new ListCompositeType(Root, HISTORICAL_ROOTS_LIMIT),
+    // Eth1
+    eth1Data: phase0Ssz.Eth1Data,
+    eth1DataVotes: phase0Ssz.Eth1DataVotes,
+    eth1DepositIndex: UintNum64,
+    // Registry
+    validators: phase0Ssz.Validators,
+    balances: phase0Ssz.Balances,
+    randaoMixes: phase0Ssz.RandaoMixes,
+    // Slashings
+    slashings: phase0Ssz.Slashings,
+    // Participation
+    previousEpochParticipation: altairSsz.EpochParticipation,
+    currentEpochParticipation: altairSsz.EpochParticipation,
+    // Finality
+    justificationBits: phase0Ssz.JustificationBits,
+    previousJustifiedCheckpoint: phase0Ssz.Checkpoint,
+    currentJustifiedCheckpoint: phase0Ssz.Checkpoint,
+    finalizedCheckpoint: phase0Ssz.Checkpoint,
+    // Inactivity
+    inactivityScores: altairSsz.InactivityScores,
+    // Sync
+    currentSyncCommittee: altairSsz.SyncCommittee,
+    nextSyncCommittee: altairSsz.SyncCommittee,
+    // Execution
+    latestExecutionPayloadHeader: ExecutionPayloadHeader, // Modified in DENEB
+    // Withdrawals
+    nextWithdrawalIndex: capellaSsz.BeaconState.fields.nextWithdrawalIndex,
+    nextWithdrawalValidatorIndex: capellaSsz.BeaconState.fields.nextWithdrawalValidatorIndex,
+    // Deep history valid from Capella onwards
+    historicalSummaries: capellaSsz.BeaconState.fields.historicalSummaries,
+  },
+  {typeName: "BeaconState", jsonCase: "eth2"}
+);
+
+export const LightClientHeader = new ContainerType(
+  {
+    beacon: phase0Ssz.BeaconBlockHeader,
+    execution: ExecutionPayloadHeader,
+    executionBranch: capellaSsz.LightClientHeader.fields.executionBranch,
+  },
+  {typeName: "LightClientHeader", jsonCase: "eth2"}
+);
+
+export const LightClientBootstrap = new ContainerType(
+  {
+    header: LightClientHeader,
+    currentSyncCommittee: altairSsz.SyncCommittee,
+    currentSyncCommitteeBranch: altairSsz.LightClientBootstrap.fields.currentSyncCommitteeBranch,
+  },
+  {typeName: "LightClientBootstrap", jsonCase: "eth2"}
+);
+
+export const LightClientUpdate = new ContainerType(
+  {
+    attestedHeader: LightClientHeader,
+    nextSyncCommittee: altairSsz.SyncCommittee,
+    nextSyncCommitteeBranch: altairSsz.LightClientUpdate.fields.nextSyncCommitteeBranch,
+    finalizedHeader: LightClientHeader,
+    finalityBranch: altairSsz.LightClientUpdate.fields.finalityBranch,
+    syncAggregate: altairSsz.SyncAggregate,
+    signatureSlot: Slot,
+  },
+  {typeName: "LightClientUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientFinalityUpdate = new ContainerType(
+  {
+    attestedHeader: LightClientHeader,
+    finalizedHeader: LightClientHeader,
+    finalityBranch: altairSsz.LightClientFinalityUpdate.fields.finalityBranch,
+    syncAggregate: altairSsz.SyncAggregate,
+    signatureSlot: Slot,
+  },
+  {typeName: "LightClientFinalityUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientOptimisticUpdate = new ContainerType(
+  {
+    attestedHeader: LightClientHeader,
+    syncAggregate: altairSsz.SyncAggregate,
+    signatureSlot: Slot,
+  },
+  {typeName: "LightClientOptimisticUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientStore = new ContainerType(
+  {
+    snapshot: LightClientBootstrap,
+    validUpdates: new ListCompositeType(LightClientUpdate, EPOCHS_PER_SYNC_COMMITTEE_PERIOD * SLOTS_PER_EPOCH),
+  },
+  {typeName: "LightClientStore", jsonCase: "eth2"}
+);
+
+// PayloadAttributes primarily for SSE event
+export const PayloadAttributes = new ContainerType(
+  {
+    ...capellaSsz.PayloadAttributes.fields,
+    parentBeaconBlockRoot: Root,
+  },
+  {typeName: "PayloadAttributes", jsonCase: "eth2"}
+);
+
+export const SSEPayloadAttributes = new ContainerType(
+  {
+    ...bellatrixSsz.SSEPayloadAttributesCommon.fields,
+    payloadAttributes: PayloadAttributes,
+  },
+  {typeName: "SSEPayloadAttributes", jsonCase: "eth2"}
+);
+
+export const BlockContents = new ContainerType(
+  {
+    block: BeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: Blobs,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);
+
+export const SignedBlockContents = new ContainerType(
+  {
+    signedBlock: SignedBeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: Blobs,
+  },
+  {typeName: "SignedBlockContents", jsonCase: "eth2"}
+);

package/src/deneb/types.ts

@@ -0,0 +1,55 @@
+import {ValueOf} from "@chainsafe/ssz";
+import * as ssz from "./sszTypes.js";
+
+export type KZGProof = ValueOf<typeof ssz.KZGProof>;
+export type KZGCommitment = ValueOf<typeof ssz.KZGCommitment>;
+
+export type Blob = ValueOf<typeof ssz.Blob>;
+export type Blobs = ValueOf<typeof ssz.Blobs>;
+export type BlobSidecar = ValueOf<typeof ssz.BlobSidecar>;
+export type BlobSidecars = ValueOf<typeof ssz.BlobSidecars>;
+export type ExecutionPayloadAndBlobsBundle = ValueOf<typeof ssz.ExecutionPayloadAndBlobsBundle>;
+export type BlobsBundle = ValueOf<typeof ssz.BlobsBundle>;
+
+export type KzgCommitmentInclusionProof = ValueOf<typeof ssz.KzgCommitmentInclusionProof>;
+export type BlobKzgCommitments = ValueOf<typeof ssz.BlobKzgCommitments>;
+export type KZGProofs = ValueOf<typeof ssz.KZGProofs>;
+export type BLSFieldElement = ValueOf<typeof ssz.BLSFieldElement>;
+
+export type BlobIdentifier = ValueOf<typeof ssz.BlobIdentifier>;
+export type BlobSidecarsByRangeRequest = ValueOf<typeof ssz.BlobSidecarsByRangeRequest>;
+
+export type ExecutionPayload = ValueOf<typeof ssz.ExecutionPayload>;
+export type ExecutionPayloadHeader = ValueOf<typeof ssz.ExecutionPayloadHeader>;
+
+export type BeaconBlockBody = ValueOf<typeof ssz.BeaconBlockBody>;
+export type BeaconBlock = ValueOf<typeof ssz.BeaconBlock>;
+export type SignedBeaconBlock = ValueOf<typeof ssz.SignedBeaconBlock>;
+
+export type BeaconState = ValueOf<typeof ssz.BeaconState>;
+
+export type BlindedBeaconBlockBody = ValueOf<typeof ssz.BlindedBeaconBlockBody>;
+export type BlindedBeaconBlock = ValueOf<typeof ssz.BlindedBeaconBlock>;
+export type SignedBlindedBeaconBlock = ValueOf<typeof ssz.SignedBlindedBeaconBlock>;
+
+export type FullOrBlindedExecutionPayload = ExecutionPayload | ExecutionPayloadHeader;
+
+export type BuilderBid = ValueOf<typeof ssz.BuilderBid>;
+export type SignedBuilderBid = ValueOf<typeof ssz.SignedBuilderBid>;
+export type SSEPayloadAttributes = ValueOf<typeof ssz.SSEPayloadAttributes>;
+
+export type LightClientHeader = ValueOf<typeof ssz.LightClientHeader>;
+export type LightClientBootstrap = ValueOf<typeof ssz.LightClientBootstrap>;
+export type LightClientUpdate = ValueOf<typeof ssz.LightClientUpdate>;
+export type LightClientFinalityUpdate = ValueOf<typeof ssz.LightClientFinalityUpdate>;
+export type LightClientOptimisticUpdate = ValueOf<typeof ssz.LightClientOptimisticUpdate>;
+export type LightClientStore = ValueOf<typeof ssz.LightClientStore>;
+
+export type ProducedBlobSidecars = Omit<BlobSidecars, "signedBlockHeader" | "kzgCommitmentInclusionProof">;
+
+export type BlockContents = ValueOf<typeof ssz.BlockContents>;
+export type SignedBlockContents = ValueOf<typeof ssz.SignedBlockContents>;
+export type BlobAndProof = {
+  blob: Blob;
+  proof: KZGProof;
+};

package/src/electra/index.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+
+import * as ssz from "./sszTypes.js";
+import * as ts from "./types.js";
+export {ts, ssz};