feat: fulu types

packages/types/src/fulu/index.ts

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

packages/types/src/fulu/sszTypes.ts

@@ -0,0 +1,258 @@
+import {ByteVectorType, ContainerType, ListBasicType, ListCompositeType, 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,
+  MAX_REQUEST_DATA_COLUMN_SIDECARS,
+  NUMBER_OF_COLUMNS,
+} 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 {BLSSignature, Root, ColumnIndex, RowIndex, Bytes32, Slot, UintNum64} = 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 Cell = new ByteVectorType(BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_CELL);
+export const DataColumn = new ListCompositeType(Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK);
+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 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 DataColumnIdentifier = new ContainerType(
+  {
+    blockRoot: Root,
+    index: ColumnIndex,
+  },
+  {typeName: "DataColumnIdentifier", jsonCase: "eth2"}
+);
+
+export const DataColumnSidecarsByRootRequest = new ListCompositeType(
+  DataColumnIdentifier,
+  MAX_REQUEST_DATA_COLUMN_SIDECARS
+);
+
+export const DataColumnSidecarsByRangeRequest = new ContainerType(
+  {
+    startSlot: Slot,
+    count: UintNum64,
+    columns: new ListBasicType(ColumnIndex, NUMBER_OF_COLUMNS),
+  },
+  {typeName: "DataColumnSidecarsByRangeRequest", jsonCase: "eth2"}
+);
+
+export const ExecutionPayload = new ContainerType(
+  {
+    ...electraSsz.ExecutionPayload.fields,
+  },
+  {typeName: "ExecutionPayload", jsonCase: "eth2"}
+);
+
+export const ExecutionPayloadHeader = new ContainerType(
+  {
+    ...electraSsz.ExecutionPayloadHeader.fields,
+  },
+  {typeName: "ExecutionPayloadHeader", jsonCase: "eth2"}
+);
+
+export const BeaconBlockBody = new ContainerType(
+  {
+    ...electraSsz.BeaconBlockBody.fields,
+  },
+  {typeName: "BeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BeaconBlock = new ContainerType(
+  {
+    ...electraSsz.BeaconBlock.fields,
+  },
+  {typeName: "BeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBeaconBlock = new ContainerType(
+  {
+    message: BeaconBlock,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BlobSidecar = new ContainerType(
+  {
+    ...denebSsz.BlobSidecar.fields,
+  },
+  {typeName: "BlobSidecar", jsonCase: "eth2"}
+);
+
+export const BlobsBundle = new ContainerType(
+  {
+    commitments: denebSsz.BlobKzgCommitments,
+    proofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlobsBundle", jsonCase: "eth2"}
+);
+
+export const BlindedBeaconBlockBody = new ContainerType(
+  {
+    ...electraSsz.BlindedBeaconBlockBody.fields,
+  },
+  {typeName: "BlindedBeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BlindedBeaconBlock = new ContainerType(
+  {
+    ...electraSsz.BlindedBeaconBlock.fields,
+  },
+  {typeName: "BlindedBeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBlindedBeaconBlock = new ContainerType(
+  {
+    message: BlindedBeaconBlock,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBlindedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BuilderBid = new ContainerType(
+  {
+    ...electraSsz.BuilderBid.fields,
+  },
+  {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"}
+);
+
+export const BeaconState = new ContainerType(
+  {
+    ...electraSsz.BeaconState.fields,
+  },
+  {typeName: "BeaconState", jsonCase: "eth2"}
+);
+
+export const LightClientHeader = new ContainerType(
+  {
+    ...denebSsz.LightClientHeader.fields,
+  },
+  {typeName: "LightClientHeader", jsonCase: "eth2"}
+);
+
+export const LightClientBootstrap = new ContainerType(
+  {
+    ...electraSsz.LightClientBootstrap.fields,
+  },
+  {typeName: "LightClientBootstrap", jsonCase: "eth2"}
+);
+
+export const LightClientUpdate = new ContainerType(
+  {
+    ...electraSsz.LightClientUpdate.fields,
+  },
+  {typeName: "LightClientUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientFinalityUpdate = new ContainerType(
+  {
+    ...electraSsz.LightClientFinalityUpdate.fields,
+  },
+  {typeName: "LightClientFinalityUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientOptimisticUpdate = new ContainerType(
+  {
+    ...electraSsz.LightClientOptimisticUpdate.fields,
+  },
+  {typeName: "LightClientOptimisticUpdate", jsonCase: "eth2"}
+);
+
+export const LightClientStore = new ContainerType(
+  {
+    ...electraSsz.LightClientStore.fields,
+  },
+  {typeName: "LightClientStore", jsonCase: "eth2"}
+);
+
+export const SSEPayloadAttributes = new ContainerType(
+  {
+    ...electraSsz.SSEPayloadAttributes.fields,
+  },
+  {typeName: "SSEPayloadAttributes", jsonCase: "eth2"}
+);
+
+export const BlockContents = new ContainerType(
+  {
+    block: BeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);
+
+export const SignedBlockContents = new ContainerType(
+  {
+    signedBlock: SignedBeaconBlock,
+    kzgProofs: KZGProofs,
+    blobs: denebSsz.Blobs,
+  },
+  {typeName: "SignedBlockContents", jsonCase: "eth2"}
+);

packages/types/src/fulu/types.ts

@@ -0,0 +1,53 @@
+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 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 DataColumnIdentifier = ValueOf<typeof ssz.DataColumnIdentifier>;
+export type DataColumnSidecarsByRootRequest = ValueOf<typeof ssz.DataColumnSidecarsByRootRequest>;
+export type DataColumnSidecarsByRangeRequest = ValueOf<typeof ssz.DataColumnSidecarsByRangeRequest>;
+
+export type ExecutionPayloadAndBlobsBundle = ValueOf<typeof ssz.ExecutionPayloadAndBlobsBundle>;
+
+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 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 BlockContents = ValueOf<typeof ssz.BlockContents>;
+export type SignedBlockContents = ValueOf<typeof ssz.SignedBlockContents>;
+export type Contents = Omit<BlockContents, "block">;
+export type BlobAndProofV2 = {
+  blob: Blob;
+  proofs: KZGProof[];
+};

packages/types/src/primitive/sszTypes.ts

@@ -65,3 +65,5 @@ export const BLSSignature = Bytes96;
 export const Domain = Bytes32;
 export const ParticipationFlags = new UintNumberType(1, {setBitwiseOR: true});
 export const ExecutionAddress = new ExecutionAddressType();
+export const ColumnIndex = UintNum64;
+export const RowIndex = UintNum64;

packages/types/src/primitive/types.ts

@@ -48,3 +48,5 @@ export type ExecutionAddress = Bytes20;
 export type RootHex = string;
 /** Non-spec type to signal time is represented in seconds */
 export type TimeSeconds = number;
+export type ColumnIndex = UintNum64; // in reality this number is u8 and can be treated as a JS Number
+export type CustodyIndex = UintNum64; // in reality this number is u8 and can be treated as a JS Number

packages/types/src/sszTypes.ts

@@ -5,10 +5,11 @@ import {ssz as bellatrix} from "./bellatrix/index.js";
 import {ssz as capella} from "./capella/index.js";
 import {ssz as deneb} from "./deneb/index.js";
 import {ssz as electra} from "./electra/index.js";
+import {ssz as fulu} from "./fulu/index.js";
 import {ssz as phase0} from "./phase0/index.js";
 
 export * from "./primitive/sszTypes.js";
-export {phase0, altair, bellatrix, capella, deneb, electra, electra as fulu};
+export {phase0, altair, bellatrix, capella, deneb, electra, fulu};
 
 /**
  * Index the ssz types that differ by fork
@@ -21,7 +22,7 @@ const typesByFork = {
   [ForkName.capella]: {...phase0, ...altair, ...bellatrix, ...capella},
   [ForkName.deneb]: {...phase0, ...altair, ...bellatrix, ...capella, ...deneb},
   [ForkName.electra]: {...phase0, ...altair, ...bellatrix, ...capella, ...deneb, ...electra},
-  [ForkName.fulu]: {...phase0, ...altair, ...bellatrix, ...capella, ...deneb, ...electra},
+  [ForkName.fulu]: {...phase0, ...altair, ...bellatrix, ...capella, ...deneb, ...electra, ...fulu},
 };
 
 /**