@lodestar/types 1.46.0-dev.d9bad172a8 → 1.46.0-dev.de5f89eae1

package/src/heze/sszTypes.ts

@@ -0,0 +1,128 @@
+import {
+  BitVectorType,
+  ContainerType,
+  ProgressiveContainerType,
+  ProgressiveListCompositeType,
+  VectorBasicType,
+} from "@chainsafe/ssz";
+import {INCLUSION_LIST_COMMITTEE_SIZE} from "@lodestar/params";
+import {ssz as gloasSsz} from "../gloas/index.js";
+import {ssz as primitiveSsz} from "../primitive/index.js";
+
+const {Slot, Root, BLSSignature, ValidatorIndex} = primitiveSsz;
+
+function activeFields(count: number): boolean[] {
+  return Array.from({length: count}, () => true);
+}
+
+export const InclusionListCommittee = new VectorBasicType(ValidatorIndex, INCLUSION_LIST_COMMITTEE_SIZE);
+
+export const InclusionListTransactions = new ProgressiveListCompositeType(gloasSsz.Transaction, {
+  typeName: "InclusionListTransactions",
+});
+
+export const InclusionList = new ContainerType(
+  {
+    slot: Slot,
+    validatorIndex: ValidatorIndex,
+    inclusionListCommitteeRoot: Root,
+    transactions: InclusionListTransactions,
+  },
+  {typeName: "InclusionList", jsonCase: "eth2"}
+);
+
+export const SignedInclusionList = new ContainerType(
+  {
+    message: InclusionList,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedInclusionList", jsonCase: "eth2"}
+);
+
+export const InclusionListsByIndicesRequest = new ContainerType(
+  {
+    slot: Slot,
+    inclusionListCommitteeRoot: Root,
+    indices: new BitVectorType(INCLUSION_LIST_COMMITTEE_SIZE),
+  },
+  {typeName: "InclusionListsByIndicesRequest", jsonCase: "eth2"}
+);
+
+export const ExecutionPayloadBid = new ProgressiveContainerType(
+  {
+    ...gloasSsz.ExecutionPayloadBid.fields,
+    inclusionListBits: new BitVectorType(INCLUSION_LIST_COMMITTEE_SIZE), // [New in Heze:EIP7805]
+  },
+  activeFields(13),
+  {typeName: "ExecutionPayloadBid", jsonCase: "eth2"}
+);
+
+export const SignedExecutionPayloadBid = new ContainerType(
+  {
+    message: ExecutionPayloadBid, // [Modified in Heze:EIP7805]
+    signature: BLSSignature,
+  },
+  {typeName: "SignedExecutionPayloadBid", jsonCase: "eth2"}
+);
+
+export const DataColumnSidecar = gloasSsz.DataColumnSidecar;
+export const DataColumnSidecars = gloasSsz.DataColumnSidecars;
+
+export const BeaconState = new ProgressiveContainerType(
+  {
+    ...gloasSsz.BeaconState.fields,
+    latestExecutionPayloadBid: ExecutionPayloadBid, // [Modified in Heze:EIP7805]
+  },
+  activeFields(46),
+  {typeName: "BeaconState", jsonCase: "eth2"}
+);
+
+export const BeaconBlockBody = new ProgressiveContainerType(
+  {
+    ...gloasSsz.BeaconBlockBody.fields,
+    signedExecutionPayloadBid: SignedExecutionPayloadBid, // [Modified in Heze:EIP7805]
+  },
+  activeFields(13),
+  {typeName: "BeaconBlockBody", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const BeaconBlock = new ContainerType(
+  {
+    ...gloasSsz.BeaconBlock.fields,
+    body: BeaconBlockBody,
+  },
+  {typeName: "BeaconBlock", jsonCase: "eth2", cachePermanentRootStruct: true}
+);
+
+export const SignedBeaconBlock = new ContainerType(
+  {
+    message: BeaconBlock,
+    signature: BLSSignature,
+  },
+  {typeName: "SignedBeaconBlock", jsonCase: "eth2"}
+);
+
+export const BlockContents = new ContainerType(
+  {
+    ...gloasSsz.BlockContents.fields,
+    block: BeaconBlock,
+  },
+  {typeName: "BlockContents", jsonCase: "eth2"}
+);
+
+// PayloadAttributes primarily for SSE event
+export const PayloadAttributes = new ContainerType(
+  {
+    ...gloasSsz.PayloadAttributes.fields,
+    inclusionListTransactions: InclusionListTransactions, // [New in Heze:EIP7805]
+  },
+  {typeName: "PayloadAttributes", jsonCase: "eth2"}
+);
+
+export const SSEPayloadAttributes = new ContainerType(
+  {
+    ...gloasSsz.SSEPayloadAttributes.fields,
+    payloadAttributes: PayloadAttributes, // [Modified in Heze:EIP7805]
+  },
+  {typeName: "SSEPayloadAttributes", jsonCase: "eth2"}
+);

package/src/heze/types.ts

@@ -0,0 +1,17 @@
+import {ValueOf} from "@chainsafe/ssz";
+import * as ssz from "./sszTypes.js";
+
+export type InclusionListCommittee = ValueOf<typeof ssz.InclusionListCommittee>;
+export type InclusionList = ValueOf<typeof ssz.InclusionList>;
+export type SignedInclusionList = ValueOf<typeof ssz.SignedInclusionList>;
+export type InclusionListsByIndicesRequest = ValueOf<typeof ssz.InclusionListsByIndicesRequest>;
+
+export type ExecutionPayloadBid = ValueOf<typeof ssz.ExecutionPayloadBid>;
+export type SignedExecutionPayloadBid = ValueOf<typeof ssz.SignedExecutionPayloadBid>;
+
+export type BeaconState = ValueOf<typeof ssz.BeaconState>;
+export type BeaconBlockBody = ValueOf<typeof ssz.BeaconBlockBody>;
+export type BeaconBlock = ValueOf<typeof ssz.BeaconBlock>;
+export type SignedBeaconBlock = ValueOf<typeof ssz.SignedBeaconBlock>;
+export type BlockContents = ValueOf<typeof ssz.BlockContents>;
+export type SSEPayloadAttributes = ValueOf<typeof ssz.SSEPayloadAttributes>;

package/src/phase0/sszTypes.ts

@@ -146,7 +146,8 @@ export const DepositEvent = new ContainerType(
 export const Eth1Data = new ContainerType(
   {
     depositRoot: Root,
-    depositCount: UintNum64,
+    // Proposer can set any value, must cover the full uint64 range
+    depositCount: UintBn64,
     blockHash: Bytes32,
   },
   {typeName: "Eth1Data", jsonCase: "eth2"}

package/src/sszTypes.ts

@@ -7,6 +7,7 @@ import {ssz as denebSsz} from "./deneb/index.js";
 import {ssz as electraSsz} from "./electra/index.js";
 import {ssz as fuluSsz} from "./fulu/index.js";
 import {ssz as gloasSsz} from "./gloas/index.js";
+import {ssz as hezeSsz} from "./heze/index.js";
 import {ssz as phase0Ssz} from "./phase0/index.js";
 
 export * from "./primitive/sszTypes.js";
@@ -33,6 +34,17 @@ const typesByFork = {
     ...fuluSsz,
     ...gloasSsz,
   },
+  [ForkName.heze]: {
+    ...phase0Ssz,
+    ...altairSsz,
+    ...bellatrixSsz,
+    ...capellaSsz,
+    ...denebSsz,
+    ...electraSsz,
+    ...fuluSsz,
+    ...gloasSsz,
+    ...hezeSsz,
+  },
 };
 
 // Export these types to ensure that each fork is a superset of the previous one (with overridden types obviously)
@@ -46,6 +58,7 @@ export const deneb = typesByFork[ForkName.deneb];
 export const electra = typesByFork[ForkName.electra];
 export const fulu = typesByFork[ForkName.fulu];
 export const gloas = typesByFork[ForkName.gloas];
+export const heze = typesByFork[ForkName.heze];
 
 /**
  * A type of union of forks must accept as any parameter the UNION of all fork types.

package/src/types.ts

@@ -15,6 +15,7 @@ import {ts as deneb} from "./deneb/index.js";
 import {ts as electra} from "./electra/index.js";
 import {ts as fulu} from "./fulu/index.js";
 import {ts as gloas} from "./gloas/index.js";
+import {ts as heze} from "./heze/index.js";
 import {ts as phase0} from "./phase0/index.js";
 import {Slot} from "./primitive/types.js";
 
@@ -25,6 +26,7 @@ export {ts as deneb} from "./deneb/index.js";
 export {ts as electra} from "./electra/index.js";
 export {ts as fulu} from "./fulu/index.js";
 export {ts as gloas} from "./gloas/index.js";
+export {ts as heze} from "./heze/index.js";
 export {ts as phase0} from "./phase0/index.js";
 export * from "./primitive/types.js";
 
@@ -326,6 +328,47 @@ type TypesByFork = {
     DataColumnSidecar: gloas.DataColumnSidecar;
     DataColumnSidecars: gloas.DataColumnSidecars;
   };
+  [ForkName.heze]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: heze.BeaconBlock;
+    BeaconBlockBody: heze.BeaconBlockBody;
+    BeaconState: heze.BeaconState;
+    SignedBeaconBlock: heze.SignedBeaconBlock;
+    Metadata: fulu.Metadata;
+    Status: fulu.Status;
+    LightClientHeader: gloas.LightClientHeader;
+    LightClientBootstrap: gloas.LightClientBootstrap;
+    LightClientUpdate: gloas.LightClientUpdate;
+    LightClientFinalityUpdate: gloas.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: gloas.LightClientOptimisticUpdate;
+    LightClientStore: gloas.LightClientStore;
+    BlindedBeaconBlock: electra.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: electra.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: electra.SignedBlindedBeaconBlock;
+    ExecutionPayload: gloas.ExecutionPayload;
+    ExecutionPayloadHeader: deneb.ExecutionPayloadHeader;
+    BuilderBid: electra.BuilderBid;
+    SignedBuilderBid: electra.SignedBuilderBid;
+    SSEPayloadAttributes: heze.SSEPayloadAttributes;
+    BlockContents: heze.BlockContents;
+    SignedBlockContents: fulu.SignedBlockContents;
+    ExecutionPayloadAndBlobsBundle: fulu.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: fulu.BlobsBundle;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: electra.SingleAttestation;
+    Attestation: gloas.Attestation;
+    IndexedAttestation: gloas.IndexedAttestation;
+    IndexedAttestationBigint: gloas.IndexedAttestationBigint;
+    AttesterSlashing: gloas.AttesterSlashing;
+    AggregateAndProof: gloas.AggregateAndProof;
+    SignedAggregateAndProof: gloas.SignedAggregateAndProof;
+    ExecutionRequests: gloas.ExecutionRequests;
+    ExecutionPayloadBid: heze.ExecutionPayloadBid;
+    DataColumnSidecar: gloas.DataColumnSidecar;
+    DataColumnSidecars: gloas.DataColumnSidecars;
+  };
 };
 
 export type TypesFor<F extends ForkName, K extends keyof TypesByFork[F] | void = void> = K extends void