@lodestar/types 1.35.0-dev.8ea34e52ba → 1.35.0-dev.91dadf81de

package/src/electra/sszTypes.ts

@@ -0,0 +1,451 @@
+import {
+  BitListType,
+  BitVectorType,
+  ContainerType,
+  ListBasicType,
+  ListCompositeType,
+  VectorCompositeType,
+} from "@chainsafe/ssz";
+import {
+  CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA,
+  EPOCHS_PER_SYNC_COMMITTEE_PERIOD,
+  FINALIZED_ROOT_DEPTH_ELECTRA,
+  HISTORICAL_ROOTS_LIMIT,
+  MAX_ATTESTATIONS_ELECTRA,
+  MAX_ATTESTER_SLASHINGS_ELECTRA,
+  MAX_COMMITTEES_PER_SLOT,
+  MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD,
+  MAX_DEPOSIT_REQUESTS_PER_PAYLOAD,
+  MAX_VALIDATORS_PER_COMMITTEE,
+  MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD,
+  NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA,
+  PENDING_CONSOLIDATIONS_LIMIT,
+  PENDING_DEPOSITS_LIMIT,
+  PENDING_PARTIAL_WITHDRAWALS_LIMIT,
+  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 denebSsz} from "../deneb/index.js";
+import {ssz as phase0Ssz} from "../phase0/index.js";
+import {ssz as primitiveSsz} from "../primitive/index.js";
+
+const {
+  Epoch,
+  Gwei,
+  UintNum64,
+  Slot,
+  Root,
+  BLSSignature,
+  UintBn256,
+  Bytes32,
+  BLSPubkey,
+  DepositIndex,
+  UintBn64,
+  ExecutionAddress,
+  ValidatorIndex,
+  CommitteeIndex,
+} = primitiveSsz;
+
+export const CurrentSyncCommitteeBranch = new VectorCompositeType(Bytes32, CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA);
+
+export const FinalityBranch = new VectorCompositeType(Bytes32, FINALIZED_ROOT_DEPTH_ELECTRA);
+
+export const NextSyncCommitteeBranch = new VectorCompositeType(Bytes32, NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA);
+
+export const AggregationBits = new BitListType(MAX_VALIDATORS_PER_COMMITTEE * MAX_COMMITTEES_PER_SLOT);
+
+// This CommitteeBits serves a different purpose than CommitteeBits in phase0
+// TODO Electra: Rename phase0.CommitteeBits to ParticipationBits to avoid confusion
+export const CommitteeBits = new BitVectorType(MAX_COMMITTEES_PER_SLOT);
+
+export const AttestingIndices = new ListBasicType(
+  ValidatorIndex,
+  MAX_VALIDATORS_PER_COMMITTEE * MAX_COMMITTEES_PER_SLOT
+);
+
+export const Attestation = new ContainerType(
+  {
+    aggregationBits: AggregationBits, // Modified in ELECTRA
+    data: phase0Ssz.AttestationData,
+    signature: BLSSignature,
+    committeeBits: CommitteeBits, // New in ELECTRA
+  },
+  {typeName: "Attestation", jsonCase: "eth2"}
+);
+
+// New type in ELECTRA
+export const SingleAttestation = new ContainerType(
+  {
+    committeeIndex: CommitteeIndex,
+    attesterIndex: ValidatorIndex,
+    data: phase0Ssz.AttestationData,
+    signature: BLSSignature,
+  },
+  {typeName: "SingleAttestation", jsonCase: "eth2"}
+);
+
+export const IndexedAttestation = new ContainerType(
+  {
+    attestingIndices: AttestingIndices, // Modified in ELECTRA
+    data: phase0Ssz.AttestationData,
+    signature: BLSSignature,
+  },
+  {typeName: "IndexedAttestation", jsonCase: "eth2"}
+);
+
+/** Same as `IndexedAttestation` but epoch, slot and index are not bounded and must be a bigint */
+export const IndexedAttestationBigint = new ContainerType(
+  {
+    attestingIndices: AttestingIndices, // Modified in ELECTRA
+    data: phase0Ssz.AttestationDataBigint,
+    signature: BLSSignature,
+  },
+  {typeName: "IndexedAttestation", jsonCase: "eth2"}
+);
+
+export const AttesterSlashing = new ContainerType(
+  {
+    attestation1: IndexedAttestationBigint, // Modified in ELECTRA
+    attestation2: IndexedAttestationBigint, // Modified in ELECTRA
+  },
+  {typeName: "AttesterSlashing", jsonCase: "eth2"}
+);
+
+export const AggregateAndProof = new ContainerType(
+  {
+    aggregatorIndex: ValidatorIndex,
+    aggregate: Attestation, // Modified in ELECTRA
+    selectionProof: BLSSignature,
+  },
+  {typeName: "AggregateAndProof", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedAggregateAndProof = new ContainerType(
+  {
+    message: AggregateAndProof, // Modified in ELECTRA
+    signature: BLSSignature,
+  },
+  {typeName: "SignedAggregateAndProof", jsonCase: "eth2"}
+);
+
+export const DepositRequest = new ContainerType(
+  {
+    pubkey: BLSPubkey,
+    withdrawalCredentials: Bytes32,
+    // this is actually gwei uintbn64 type, but super unlikely to get a high amount here
+    // to warrant a bn type
+    amount: UintNum64,
+    signature: BLSSignature,
+    index: DepositIndex,
+  },
+  {typeName: "DepositRequest", jsonCase: "eth2"}
+);
+
+export const DepositRequests = new ListCompositeType(DepositRequest, MAX_DEPOSIT_REQUESTS_PER_PAYLOAD);
+
+export const WithdrawalRequest = new ContainerType(
+  {
+    sourceAddress: ExecutionAddress,
+    validatorPubkey: BLSPubkey,
+    amount: Gwei,
+  },
+  {typeName: "WithdrawalRequest", jsonCase: "eth2"}
+);
+export const WithdrawalRequests = new ListCompositeType(WithdrawalRequest, MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD);
+export const ConsolidationRequest = new ContainerType(
+  {
+    sourceAddress: ExecutionAddress,
+    sourcePubkey: BLSPubkey,
+    targetPubkey: BLSPubkey,
+  },
+  {typeName: "ConsolidationRequest", jsonCase: "eth2"}
+);
+export const ConsolidationRequests = new ListCompositeType(
+  ConsolidationRequest,
+  MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD
+);
+
+export const ExecutionRequests = new ContainerType(
+  {
+    deposits: DepositRequests,
+    withdrawals: WithdrawalRequests,
+    consolidations: ConsolidationRequests,
+  },
+  {typeName: "ExecutionRequests", jsonCase: "eth2"}
+);
+
+// Explicitly defining electra containers for consistency's sake
+export const ExecutionPayloadHeader = denebSsz.ExecutionPayloadHeader;
+export const ExecutionPayload = denebSsz.ExecutionPayload;
+
+// We have to preserve Fields ordering while changing the type of ExecutionPayload
+export const BeaconBlockBody = new ContainerType(
+  {
+    randaoReveal: phase0Ssz.BeaconBlockBody.fields.randaoReveal,
+    eth1Data: phase0Ssz.BeaconBlockBody.fields.eth1Data,
+    graffiti: phase0Ssz.BeaconBlockBody.fields.graffiti,
+    proposerSlashings: phase0Ssz.BeaconBlockBody.fields.proposerSlashings,
+    attesterSlashings: new ListCompositeType(AttesterSlashing, MAX_ATTESTER_SLASHINGS_ELECTRA), // Modified in ELECTRA
+    attestations: new ListCompositeType(Attestation, MAX_ATTESTATIONS_ELECTRA), // Modified in ELECTRA
+    deposits: phase0Ssz.BeaconBlockBody.fields.deposits,
+    voluntaryExits: phase0Ssz.BeaconBlockBody.fields.voluntaryExits,
+    syncAggregate: altairSsz.BeaconBlockBody.fields.syncAggregate,
+    executionPayload: ExecutionPayload,
+    blsToExecutionChanges: capellaSsz.BeaconBlockBody.fields.blsToExecutionChanges,
+    blobKzgCommitments: denebSsz.BeaconBlockBody.fields.blobKzgCommitments,
+    executionRequests: ExecutionRequests, // New in ELECTRA:EIP7251
+  },
+  {typeName: "BeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BeaconBlock = new ContainerType(
+  {
+    ...denebSsz.BeaconBlock.fields,
+    body: BeaconBlockBody, // Modified in ELECTRA
+  },
+  {typeName: "BeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBeaconBlock = new ContainerType(
+  {
+    message: BeaconBlock, // Modified in ELECTRA
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BlindedBeaconBlockBody = new ContainerType(
+  {
+    randaoReveal: phase0Ssz.BeaconBlockBody.fields.randaoReveal,
+    eth1Data: phase0Ssz.BeaconBlockBody.fields.eth1Data,
+    graffiti: phase0Ssz.BeaconBlockBody.fields.graffiti,
+    proposerSlashings: phase0Ssz.BeaconBlockBody.fields.proposerSlashings,
+    attesterSlashings: new ListCompositeType(AttesterSlashing, MAX_ATTESTER_SLASHINGS_ELECTRA), // Modified in ELECTRA
+    attestations: new ListCompositeType(Attestation, MAX_ATTESTATIONS_ELECTRA), // Modified in ELECTRA
+    deposits: phase0Ssz.BeaconBlockBody.fields.deposits,
+    voluntaryExits: phase0Ssz.BeaconBlockBody.fields.voluntaryExits,
+    syncAggregate: altairSsz.SyncAggregate,
+    executionPayloadHeader: ExecutionPayloadHeader,
+    blsToExecutionChanges: capellaSsz.BeaconBlockBody.fields.blsToExecutionChanges,
+    blobKzgCommitments: denebSsz.BeaconBlockBody.fields.blobKzgCommitments,
+    executionRequests: ExecutionRequests, // New in ELECTRA
+  },
+  {typeName: "BlindedBeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BlindedBeaconBlock = new ContainerType(
+  {
+    ...denebSsz.BlindedBeaconBlock.fields,
+    body: BlindedBeaconBlockBody, // Modified in ELECTRA
+  },
+  {typeName: "BlindedBeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBlindedBeaconBlock = new ContainerType(
+  {
+    message: BlindedBeaconBlock, // Modified in ELECTRA
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBlindedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BuilderBid = new ContainerType(
+  {
+    header: ExecutionPayloadHeader, // Modified in ELECTRA
+    blobKzgCommitments: denebSsz.BlobKzgCommitments,
+    executionRequests: ExecutionRequests, // New in ELECTRA
+    value: UintBn256,
+    pubkey: BLSPubkey,
+  },
+  {typeName: "BuilderBid", jsonCase: "eth2"}
+);
+
+export const SignedBuilderBid = new ContainerType(
+  {
+    message: BuilderBid,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBuilderBid", jsonCase: "eth2"}
+);
+
+export const PendingDeposit = new ContainerType(
+  {
+    pubkey: BLSPubkey,
+    withdrawalCredentials: Bytes32,
+    // this is actually gwei uintbn64 type, but super unlikely to get a high amount here
+    // to warrant a bn type
+    amount: UintNum64,
+    signature: BLSSignature,
+    slot: Slot,
+  },
+  {typeName: "PendingDeposit", jsonCase: "eth2"}
+);
+
+export const PendingDeposits = new ListCompositeType(PendingDeposit, PENDING_DEPOSITS_LIMIT);
+
+export const PendingPartialWithdrawal = new ContainerType(
+  {
+    validatorIndex: ValidatorIndex,
+    amount: Gwei,
+    withdrawableEpoch: Epoch,
+  },
+  {typeName: "PendingPartialWithdrawal", jsonCase: "eth2"}
+);
+
+export const PendingPartialWithdrawals = new ListCompositeType(
+  PendingPartialWithdrawal,
+  PENDING_PARTIAL_WITHDRAWALS_LIMIT
+);
+
+export const PendingConsolidation = new ContainerType(
+  {
+    sourceIndex: ValidatorIndex,
+    targetIndex: ValidatorIndex,
+  },
+  {typeName: "PendingConsolidation", jsonCase: "eth2"}
+);
+
+export const PendingConsolidations = new ListCompositeType(PendingConsolidation, PENDING_CONSOLIDATIONS_LIMIT);
+
+// In EIP-7251, we spread deneb fields as new fields are appended at the end
+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,
+    // Withdrawals
+    nextWithdrawalIndex: capellaSsz.BeaconState.fields.nextWithdrawalIndex,
+    nextWithdrawalValidatorIndex: capellaSsz.BeaconState.fields.nextWithdrawalValidatorIndex,
+    // Deep history valid from Capella onwards
+    historicalSummaries: capellaSsz.BeaconState.fields.historicalSummaries,
+    depositRequestsStartIndex: UintBn64, // New in ELECTRA:EIP6110
+    depositBalanceToConsume: Gwei, // New in ELECTRA:EIP7251
+    exitBalanceToConsume: Gwei, // New in ELECTRA:EIP7251
+    earliestExitEpoch: Epoch, // New in ELECTRA:EIP7251
+    consolidationBalanceToConsume: Gwei, // New in ELECTRA:EIP7251
+    earliestConsolidationEpoch: Epoch, // New in ELECTRA:EIP7251
+    pendingDeposits: PendingDeposits, // New in ELECTRA:EIP7251
+    pendingPartialWithdrawals: PendingPartialWithdrawals, // New in ELECTRA:EIP7251
+    pendingConsolidations: PendingConsolidations, // New in ELECTRA:EIP7251
+  },
+  {typeName: "BeaconState", jsonCase: "eth2"}
+);
+
+export const LightClientBootstrap = new ContainerType(
+  {
+    header: denebSsz.LightClientHeader,
+    currentSyncCommittee: altairSsz.SyncCommittee,
+    currentSyncCommitteeBranch: CurrentSyncCommitteeBranch,
+  },
+  {typeName: "LightClientBootstrap", jsonCase: "eth2"}
+);
+
+export const LightClientUpdate = new ContainerType(
+  {
+    attestedHeader: denebSsz.LightClientHeader,
+    nextSyncCommittee: altairSsz.SyncCommittee,
+    nextSyncCommitteeBranch: NextSyncCommitteeBranch, // Modified in ELECTRA
+    finalizedHeader: denebSsz.LightClientHeader,
+    finalityBranch: FinalityBranch, // Modified in ELECTRA
+    syncAggregate: altairSsz.SyncAggregate,
+    signatureSlot: Slot,
+  },
+  {typeName: "LightClientUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientFinalityUpdate = new ContainerType(
+  {
+    attestedHeader: denebSsz.LightClientHeader,
+    finalizedHeader: denebSsz.LightClientHeader,
+    finalityBranch: FinalityBranch, // Modified in ELECTRA
+    syncAggregate: altairSsz.SyncAggregate,
+    signatureSlot: Slot,
+  },
+  {typeName: "LightClientFinalityUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientOptimisticUpdate = new ContainerType(
+  {
+    attestedHeader: denebSsz.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: denebSsz.KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);
+
+export const SignedBlockContents = new ContainerType(
+  {
+    signedBlock: SignedBeaconBlock,
+    kzgProofs: denebSsz.KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);

package/src/electra/types.ts

@@ -0,0 +1,54 @@
+import {ValueOf} from "@chainsafe/ssz";
+import * as ssz from "./sszTypes.js";
+
+export type Attestation = ValueOf<typeof ssz.Attestation>;
+export type SingleAttestation = ValueOf<typeof ssz.SingleAttestation>;
+export type IndexedAttestation = ValueOf<typeof ssz.IndexedAttestation>;
+export type IndexedAttestationBigint = ValueOf<typeof ssz.IndexedAttestationBigint>;
+export type AttesterSlashing = ValueOf<typeof ssz.AttesterSlashing>;
+
+export type AggregateAndProof = ValueOf<typeof ssz.AggregateAndProof>;
+export type SignedAggregateAndProof = ValueOf<typeof ssz.SignedAggregateAndProof>;
+
+export type DepositRequest = ValueOf<typeof ssz.DepositRequest>;
+export type DepositRequests = ValueOf<typeof ssz.DepositRequests>;
+
+export type WithdrawalRequest = ValueOf<typeof ssz.WithdrawalRequest>;
+export type WithdrawalRequests = ValueOf<typeof ssz.WithdrawalRequests>;
+
+export type ConsolidationRequest = ValueOf<typeof ssz.ConsolidationRequest>;
+export type ConsolidationRequests = ValueOf<typeof ssz.ConsolidationRequests>;
+
+export type ExecutionPayload = ValueOf<typeof ssz.ExecutionPayload>;
+export type ExecutionPayloadHeader = ValueOf<typeof ssz.ExecutionPayloadHeader>;
+export type ExecutionRequests = ValueOf<typeof ssz.ExecutionRequests>;
+
+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 BuilderBid = ValueOf<typeof ssz.BuilderBid>;
+export type SignedBuilderBid = ValueOf<typeof ssz.SignedBuilderBid>;
+export type SSEPayloadAttributes = ValueOf<typeof ssz.SSEPayloadAttributes>;
+
+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 PendingDeposit = ValueOf<typeof ssz.PendingDeposit>;
+export type PendingDeposits = ValueOf<typeof ssz.PendingDeposits>;
+export type PendingPartialWithdrawal = ValueOf<typeof ssz.PendingPartialWithdrawal>;
+export type PendingPartialWithdrawals = ValueOf<typeof ssz.PendingPartialWithdrawals>;
+export type PendingConsolidation = ValueOf<typeof ssz.PendingConsolidation>;
+export type PendingConsolidations = ValueOf<typeof ssz.PendingConsolidations>;
+
+export type BlockContents = ValueOf<typeof ssz.BlockContents>;
+export type SignedBlockContents = ValueOf<typeof ssz.SignedBlockContents>;

package/src/fulu/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};

package/src/fulu/sszTypes.ts

@@ -0,0 +1,138 @@
+import {
+  ByteVectorType,
+  ContainerType,
+  ListBasicType,
+  ListCompositeType,
+  VectorBasicType,
+  VectorCompositeType,
+} from "@chainsafe/ssz";
+import {
+  BYTES_PER_FIELD_ELEMENT,
+  FIELD_ELEMENTS_PER_CELL,
+  FIELD_ELEMENTS_PER_EXT_BLOB,
+  KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH,
+  MAX_BLOB_COMMITMENTS_PER_BLOCK,
+  MIN_SEED_LOOKAHEAD,
+  NUMBER_OF_COLUMNS,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {ssz as altairSsz} from "../altair/index.js";
+import {ssz as denebSsz} from "../deneb/index.js";
+import {ssz as electraSsz} from "../electra/index.js";
+import {ssz as phase0Ssz} from "../phase0/index.js";
+import {ssz as primitiveSsz} from "../primitive/index.js";
+
+const {Root, ColumnIndex, RowIndex, Bytes32, Slot, UintNum64, ValidatorIndex} = primitiveSsz;
+
+export const KZGProof = denebSsz.KZGProof;
+export const Blob = denebSsz.Blob;
+
+export const Metadata = new ContainerType(
+  {
+    ...altairSsz.Metadata.fields,
+    custodyGroupCount: UintNum64,
+  },
+  {typeName: "Metadata", jsonCase: "eth2"}
+);
+export const Status = new ContainerType(
+  {
+    ...phase0Ssz.Status.fields,
+    earliestAvailableSlot: Slot,
+  },
+  {typeName: "Status", jsonCase: "eth2"}
+);
+
+export const Cell = new ByteVectorType(BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_CELL);
+export const DataColumn = new ListCompositeType(Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+export const DataColumns = new ListCompositeType(DataColumn, NUMBER_OF_COLUMNS);
+export const ExtendedMatrix = new ListCompositeType(Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK * NUMBER_OF_COLUMNS);
+export const KzgCommitmentsInclusionProof = new VectorCompositeType(Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH);
+export const KZGProofs = new ListCompositeType(
+  denebSsz.KZGProof,
+  FIELD_ELEMENTS_PER_EXT_BLOB * MAX_BLOB_COMMITMENTS_PER_BLOCK
+);
+export const ProposerLookahead = new VectorBasicType(ValidatorIndex, (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH);
+
+export const DataColumnSidecar = new ContainerType(
+  {
+    index: ColumnIndex,
+    column: DataColumn,
+    kzgCommitments: denebSsz.BlobKzgCommitments,
+    kzgProofs: denebSsz.KZGProofs,
+    signedBlockHeader: phase0Ssz.SignedBeaconBlockHeader,
+    kzgCommitmentsInclusionProof: KzgCommitmentsInclusionProof,
+  },
+  {typeName: "DataColumnSidecar", jsonCase: "eth2"}
+);
+
+export const DataColumnSidecars = new ListCompositeType(DataColumnSidecar, NUMBER_OF_COLUMNS);
+
+export const MatrixEntry = new ContainerType(
+  {
+    cell: Cell,
+    kzgProof: denebSsz.KZGProof,
+    columnIndex: ColumnIndex,
+    rowIndex: RowIndex,
+  },
+  {typeName: "MatrixEntry", jsonCase: "eth2"}
+);
+
+// ReqResp types
+// =============
+
+export const DataColumnsByRootIdentifier = new ContainerType(
+  {
+    blockRoot: Root,
+    columns: new ListBasicType(ColumnIndex, NUMBER_OF_COLUMNS),
+  },
+  {typeName: "DataColumnsByRootIdentifier", jsonCase: "eth2"}
+);
+
+export const DataColumnSidecarsByRangeRequest = new ContainerType(
+  {
+    startSlot: Slot,
+    count: UintNum64,
+    columns: new ListBasicType(ColumnIndex, NUMBER_OF_COLUMNS),
+  },
+  {typeName: "DataColumnSidecarsByRangeRequest", jsonCase: "eth2"}
+);
+
+// Explicit aliases for a few common types
+export const BeaconBlock = electraSsz.BeaconBlock;
+export const SignedBeaconBlock = electraSsz.SignedBeaconBlock;
+
+// Containers
+export const BlobsBundle = new ContainerType(
+  {
+    commitments: denebSsz.BlobKzgCommitments,
+    proofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlobsBundle", jsonCase: "eth2"}
+);
+
+export const BeaconState = new ContainerType(
+  {
+    ...electraSsz.BeaconState.fields,
+    proposerLookahead: ProposerLookahead, // New in FULU:EIP7917
+  },
+  {typeName: "BeaconState", jsonCase: "eth2"}
+);
+
+export const BlockContents = new ContainerType(
+  {
+    block: electraSsz.BeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);
+
+export const SignedBlockContents = new ContainerType(
+  {
+    signedBlock: electraSsz.SignedBeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "SignedBlockContents", jsonCase: "eth2"}
+);

package/src/fulu/types.ts

@@ -0,0 +1,31 @@
+import {ValueOf} from "@chainsafe/ssz";
+import * as ssz from "./sszTypes.js";
+
+export type KZGProof = ValueOf<typeof ssz.KZGProof>;
+export type Blob = ValueOf<typeof ssz.Blob>;
+
+export type Metadata = ValueOf<typeof ssz.Metadata>;
+export type Status = ValueOf<typeof ssz.Status>;
+
+export type Cell = ValueOf<typeof ssz.Cell>;
+export type DataColumn = ValueOf<typeof ssz.DataColumn>;
+export type ExtendedMatrix = ValueOf<typeof ssz.ExtendedMatrix>;
+export type KzgCommitmentsInclusionProof = ValueOf<typeof ssz.KzgCommitmentsInclusionProof>;
+export type DataColumnSidecar = ValueOf<typeof ssz.DataColumnSidecar>;
+export type DataColumnSidecars = ValueOf<typeof ssz.DataColumnSidecars>;
+export type MatrixEntry = ValueOf<typeof ssz.MatrixEntry>;
+
+export type ProposerLookahead = ValueOf<typeof ssz.ProposerLookahead>;
+
+export type DataColumnsByRootIdentifier = ValueOf<typeof ssz.DataColumnsByRootIdentifier>;
+export type DataColumnSidecarsByRangeRequest = ValueOf<typeof ssz.DataColumnSidecarsByRangeRequest>;
+export type BeaconBlock = ValueOf<typeof ssz.BeaconBlock>;
+export type SignedBeaconBlock = ValueOf<typeof ssz.SignedBeaconBlock>;
+export type BeaconState = ValueOf<typeof ssz.BeaconState>;
+export type BlockContents = ValueOf<typeof ssz.BlockContents>;
+export type SignedBlockContents = ValueOf<typeof ssz.SignedBlockContents>;
+export type BlobsBundle = ValueOf<typeof ssz.BlobsBundle>;
+export type BlobAndProofV2 = {
+  blob: Blob;
+  proofs: KZGProof[];
+};

package/src/gloas/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};

package/src/gloas/sszTypes.ts

@@ -0,0 +1,5 @@
+import {ssz as fuluSsz} from "../fulu/index.js";
+
+export const BeaconState = fuluSsz.BeaconState;
+export const BeaconBlock = fuluSsz.BeaconBlock;
+export const SignedBeaconBlock = fuluSsz.SignedBeaconBlock;