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

package/src/primitive/sszTypes.ts

@@ -0,0 +1,70 @@
+import {BooleanType, ByteVectorType, UintBigintType, UintNumberType} from "@chainsafe/ssz";
+import {ExecutionAddressType} from "../utils/executionAddress.js";
+
+// biome-ignore lint/suspicious/noShadowRestrictedNames: We explicitly want this name for variable
+export const Boolean = new BooleanType();
+export const Byte = new UintNumberType(1);
+export const Bytes4 = new ByteVectorType(4);
+export const Bytes8 = new ByteVectorType(8);
+export const Bytes20 = new ByteVectorType(20);
+export const Bytes32 = new ByteVectorType(32);
+export const Bytes48 = new ByteVectorType(48);
+export const Bytes96 = new ByteVectorType(96);
+export const Uint8 = new UintNumberType(1);
+export const Uint16 = new UintNumberType(2);
+export const Uint32 = new UintNumberType(4);
+export const UintNum64 = new UintNumberType(8);
+export const UintNumInf64 = new UintNumberType(8, {clipInfinity: true});
+export const UintBn64 = new UintBigintType(8);
+export const UintBn128 = new UintBigintType(16);
+export const UintBn256 = new UintBigintType(32);
+
+// Custom types, defined for type hinting and readability
+
+/**
+ * Use JS Number for performance, values must be limited to 2**52-1.
+ * Slot is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
+ */
+export const Slot = UintNum64;
+/**
+ * Use JS Number for performance, values must be limited to 2**52-1.
+ * Epoch is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
+ */
+export const Epoch = UintNum64;
+/** Same as @see Epoch + some validator properties must represent 2**52-1 also, which we map to `Infinity` */
+export const EpochInf = UintNumInf64;
+/**
+ * Use JS Number for performance, values must be limited to 2**52-1.
+ * SyncPeriod is a time unit, so in all usages it's bounded by the clock, ensuring < 2**53-1
+ */
+export const SyncPeriod = UintNum64;
+/**
+ * Use JS Number for performance, values must be limited to 2**52-1.
+ * CommitteeIndex is bounded by the max possible number of committees which is bounded by `VALIDATOR_REGISTRY_LIMIT`
+ */
+export const CommitteeIndex = UintNum64;
+/** @see CommitteeIndex */
+export const SubcommitteeIndex = UintNum64;
+/**
+ * Use JS Number for performance, values must be limited to 2**52-1.
+ * ValidatorIndex is bounded by `VALIDATOR_REGISTRY_LIMIT`
+ */
+export const ValidatorIndex = UintNum64;
+export const WithdrawalIndex = UintNum64;
+export const DepositIndex = UintBn64;
+export const Gwei = UintBn64;
+export const Wei = UintBn256;
+export const Root = new ByteVectorType(32);
+export const BlobIndex = UintNum64;
+
+export const Version = Bytes4;
+export const DomainType = Bytes4;
+export const ForkDigest = Bytes4;
+export const BLSPubkey = Bytes48;
+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 CustodyIndex = UintNum64;
+export const RowIndex = UintNum64;

package/src/primitive/types.ts

@@ -0,0 +1,53 @@
+import {ValueOf} from "@chainsafe/ssz";
+import * as ssz from "./sszTypes.js";
+
+// Each type exported here contains both a compile-time type
+// (a typescript interface) and a run-time ssz type (a javascript variable)
+// For more information, see ./index.ts
+
+export type Bytes4 = ValueOf<typeof ssz.Bytes4>;
+export type Bytes8 = ValueOf<typeof ssz.Bytes8>;
+export type Bytes20 = ValueOf<typeof ssz.Bytes20>;
+export type Bytes32 = ValueOf<typeof ssz.Bytes32>;
+export type Bytes48 = ValueOf<typeof ssz.Bytes48>;
+export type Bytes96 = ValueOf<typeof ssz.Bytes96>;
+export type Uint8 = ValueOf<typeof ssz.Uint8>;
+export type Uint16 = ValueOf<typeof ssz.Uint16>;
+export type Uint32 = ValueOf<typeof ssz.Uint32>;
+export type UintNum64 = ValueOf<typeof ssz.UintNum64>;
+export type UintNumInf64 = ValueOf<typeof ssz.UintNumInf64>;
+export type UintBn64 = ValueOf<typeof ssz.UintBn64>;
+export type UintBn128 = ValueOf<typeof ssz.UintBn128>;
+export type UintBn256 = ValueOf<typeof ssz.UintBn256>;
+
+// Custom types, defined for type hinting and readability
+
+export type Slot = UintNumInf64;
+export type Epoch = UintNumInf64;
+export type SyncPeriod = UintNum64;
+export type CommitteeIndex = UintNum64;
+export type SubcommitteeIndex = UintNum64;
+export type ValidatorIndex = UintNum64;
+export type WithdrawalIndex = UintNum64;
+export type BlobIndex = UintNum64;
+export type SubnetID = UintNum64;
+export type Gwei = UintBn64;
+export type Wei = UintBn256;
+export type Root = Bytes32;
+export type Version = Bytes4;
+export type DomainType = Bytes4;
+export type ForkDigest = Bytes4;
+export type Domain = Bytes32;
+export type BLSPubkey = Bytes48;
+export type BLSSecretKey = Bytes32;
+export type BLSSignature = Bytes96;
+export type ParticipationFlags = Uint8;
+export type ExecutionAddress = Bytes20;
+
+/** Common non-spec type to represent roots as strings */
+export type RootHex = string;
+/** Non-spec type to signal time is represented in seconds */
+export type TimeSeconds = number;
+export type ColumnIndex = UintNum64;
+export type CustodyIndex = UintNum64;
+export type RowIndex = UintNum64;

package/src/sszTypes.ts

@@ -0,0 +1,86 @@
+import {CompositeType, CompositeView, CompositeViewDU, ContainerType, ValueOf} from "@chainsafe/ssz";
+import {ForkName} 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 electraSsz} from "./electra/index.js";
+import {ssz as fuluSsz} from "./fulu/index.js";
+import {ssz as gloasSsz} from "./gloas/index.js";
+import {ssz as phase0Ssz} from "./phase0/index.js";
+
+export * from "./primitive/sszTypes.js";
+
+/**
+ * Index the ssz types that differ by fork
+ * A record of AllForksSSZTypes indexed by fork
+ */
+const typesByFork = {
+  [ForkName.phase0]: {...phase0Ssz},
+  [ForkName.altair]: {...phase0Ssz, ...altairSsz},
+  [ForkName.bellatrix]: {...phase0Ssz, ...altairSsz, ...bellatrixSsz},
+  [ForkName.capella]: {...phase0Ssz, ...altairSsz, ...bellatrixSsz, ...capellaSsz},
+  [ForkName.deneb]: {...phase0Ssz, ...altairSsz, ...bellatrixSsz, ...capellaSsz, ...denebSsz},
+  [ForkName.electra]: {...phase0Ssz, ...altairSsz, ...bellatrixSsz, ...capellaSsz, ...denebSsz, ...electraSsz},
+  [ForkName.fulu]: {...phase0Ssz, ...altairSsz, ...bellatrixSsz, ...capellaSsz, ...denebSsz, ...electraSsz, ...fuluSsz},
+  [ForkName.gloas]: {
+    ...phase0Ssz,
+    ...altairSsz,
+    ...bellatrixSsz,
+    ...capellaSsz,
+    ...denebSsz,
+    ...electraSsz,
+    ...fuluSsz,
+    ...gloasSsz,
+  },
+};
+
+// Export these types to ensure that each fork is a superset of the previous one (with overridden types obviously)
+// This allows us to only declare types that change in each fork in each fork subdirectory
+
+export const phase0 = typesByFork[ForkName.phase0];
+export const altair = typesByFork[ForkName.altair];
+export const bellatrix = typesByFork[ForkName.bellatrix];
+export const capella = typesByFork[ForkName.capella];
+export const deneb = typesByFork[ForkName.deneb];
+export const electra = typesByFork[ForkName.electra];
+export const fulu = typesByFork[ForkName.fulu];
+export const gloas = typesByFork[ForkName.gloas];
+
+/**
+ * A type of union of forks must accept as any parameter the UNION of all fork types.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+type UnionSSZForksTypeOf<UnionOfForkTypes extends ContainerType<any>> = CompositeType<
+  ValueOf<UnionOfForkTypes>,
+  CompositeView<UnionOfForkTypes>,
+  CompositeViewDU<UnionOfForkTypes>
+>;
+
+type SSZTypesByFork = {
+  [F in keyof typeof typesByFork]: {
+    [T in keyof (typeof typesByFork)[F]]: (typeof typesByFork)[F][T];
+  };
+};
+
+export type SSZTypesFor<F extends ForkName, K extends keyof SSZTypesByFork[F] | void = void> = K extends void
+  ? // It compiles fine, need to debug the error
+    // @ts-expect-error
+    {[K2 in keyof SSZTypesByFork[F]]: UnionSSZForksTypeOf<SSZTypesByFork[F][K2]>}
+  : // It compiles fine, need to debug the error
+    // @ts-expect-error
+    UnionSSZForksTypeOf<SSZTypesByFork[F][Exclude<K, void>]>;
+
+export function sszTypesFor<F extends ForkName, K extends keyof SSZTypesByFork[F] | void = void>(
+  fork: F,
+  typeName?: K
+): SSZTypesFor<F, K> {
+  const sszTypes = typesByFork[fork];
+
+  if (sszTypes === undefined) {
+    throw Error(`SSZ types for fork ${fork} are not defined`);
+  }
+
+  return (typeName === undefined ? sszTypes : sszTypes[typeName as keyof SSZTypesByFork[F]]) as SSZTypesFor<F, K>;
+}

package/src/types.ts

@@ -0,0 +1,375 @@
+import {ForkAll, ForkName, ForkPostAltair, ForkPostBellatrix, ForkPostDeneb, ForkPostElectra} from "@lodestar/params";
+import {ts as altair} from "./altair/index.js";
+import {ts as bellatrix} from "./bellatrix/index.js";
+import {ts as capella} from "./capella/index.js";
+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 phase0} from "./phase0/index.js";
+import {Slot} from "./primitive/types.js";
+
+export {ts as altair} from "./altair/index.js";
+export {ts as bellatrix} from "./bellatrix/index.js";
+export {ts as capella} from "./capella/index.js";
+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 phase0} from "./phase0/index.js";
+export * from "./primitive/types.js";
+
+/** Common non-spec type to represent roots as strings */
+export type RootHex = string;
+
+/** Handy enum to represent the block production source */
+export enum ProducedBlockSource {
+  builder = "builder",
+  engine = "engine",
+}
+
+export type WithBytes<T> = {
+  data: T;
+  /** SSZ serialized `data` bytes */
+  bytes: Uint8Array;
+};
+
+export type WithOptionalBytes<T> = {
+  data: T;
+  /** SSZ serialized `data` bytes */
+  bytes?: Uint8Array | null;
+};
+
+export type SlotRootHex = {slot: Slot; root: RootHex};
+export type SlotOptionalRoot = {slot: Slot; root?: RootHex};
+export type RootOptionalSlot = {root: RootHex; slot?: Slot};
+
+type TypesByFork = {
+  [ForkName.phase0]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: phase0.BeaconBlock;
+    BeaconBlockBody: phase0.BeaconBlockBody;
+    BeaconState: phase0.BeaconState;
+    SignedBeaconBlock: phase0.SignedBeaconBlock;
+    Metadata: phase0.Metadata;
+    Status: phase0.Status;
+    SingleAttestation: phase0.Attestation;
+    Attestation: phase0.Attestation;
+    IndexedAttestation: phase0.IndexedAttestation;
+    IndexedAttestationBigint: phase0.IndexedAttestationBigint;
+    AttesterSlashing: phase0.AttesterSlashing;
+    AggregateAndProof: phase0.AggregateAndProof;
+    SignedAggregateAndProof: phase0.SignedAggregateAndProof;
+    BlockContents: {block: phase0.BeaconBlock};
+    SignedBlockContents: {signedBlock: phase0.SignedBeaconBlock};
+  };
+  [ForkName.altair]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: altair.BeaconBlock;
+    BeaconBlockBody: altair.BeaconBlockBody;
+    BeaconState: altair.BeaconState;
+    SignedBeaconBlock: altair.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    Status: phase0.Status;
+    LightClientHeader: altair.LightClientHeader;
+    LightClientBootstrap: altair.LightClientBootstrap;
+    LightClientUpdate: altair.LightClientUpdate;
+    LightClientFinalityUpdate: altair.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: altair.LightClientOptimisticUpdate;
+    LightClientStore: altair.LightClientStore;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: phase0.Attestation;
+    Attestation: phase0.Attestation;
+    IndexedAttestation: phase0.IndexedAttestation;
+    IndexedAttestationBigint: phase0.IndexedAttestationBigint;
+    AttesterSlashing: phase0.AttesterSlashing;
+    AggregateAndProof: phase0.AggregateAndProof;
+    SignedAggregateAndProof: phase0.SignedAggregateAndProof;
+    BlockContents: {block: altair.BeaconBlock};
+    SignedBlockContents: {signedBlock: altair.SignedBeaconBlock};
+  };
+  [ForkName.bellatrix]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: bellatrix.BeaconBlock;
+    BeaconBlockBody: bellatrix.BeaconBlockBody;
+    BeaconState: bellatrix.BeaconState;
+    SignedBeaconBlock: bellatrix.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    Status: phase0.Status;
+    LightClientHeader: altair.LightClientHeader;
+    LightClientBootstrap: altair.LightClientBootstrap;
+    LightClientUpdate: altair.LightClientUpdate;
+    LightClientFinalityUpdate: altair.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: altair.LightClientOptimisticUpdate;
+    LightClientStore: altair.LightClientStore;
+    BlindedBeaconBlock: bellatrix.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: bellatrix.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: bellatrix.SignedBlindedBeaconBlock;
+    ExecutionPayload: bellatrix.ExecutionPayload;
+    ExecutionPayloadHeader: bellatrix.ExecutionPayloadHeader;
+    BuilderBid: bellatrix.BuilderBid;
+    SignedBuilderBid: bellatrix.SignedBuilderBid;
+    SSEPayloadAttributes: bellatrix.SSEPayloadAttributes;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: phase0.Attestation;
+    Attestation: phase0.Attestation;
+    IndexedAttestation: phase0.IndexedAttestation;
+    IndexedAttestationBigint: phase0.IndexedAttestationBigint;
+    AttesterSlashing: phase0.AttesterSlashing;
+    AggregateAndProof: phase0.AggregateAndProof;
+    SignedAggregateAndProof: phase0.SignedAggregateAndProof;
+    BlockContents: {block: bellatrix.BeaconBlock};
+    SignedBlockContents: {signedBlock: bellatrix.SignedBeaconBlock};
+  };
+  [ForkName.capella]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: capella.BeaconBlock;
+    BeaconBlockBody: capella.BeaconBlockBody;
+    BeaconState: capella.BeaconState;
+    SignedBeaconBlock: capella.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    Status: phase0.Status;
+    LightClientHeader: capella.LightClientHeader;
+    LightClientBootstrap: capella.LightClientBootstrap;
+    LightClientUpdate: capella.LightClientUpdate;
+    LightClientFinalityUpdate: capella.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: capella.LightClientOptimisticUpdate;
+    LightClientStore: capella.LightClientStore;
+    BlindedBeaconBlock: capella.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: capella.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: capella.SignedBlindedBeaconBlock;
+    ExecutionPayload: capella.ExecutionPayload;
+    ExecutionPayloadHeader: capella.ExecutionPayloadHeader;
+    BuilderBid: capella.BuilderBid;
+    SignedBuilderBid: capella.SignedBuilderBid;
+    SSEPayloadAttributes: capella.SSEPayloadAttributes;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: phase0.Attestation;
+    Attestation: phase0.Attestation;
+    IndexedAttestation: phase0.IndexedAttestation;
+    IndexedAttestationBigint: phase0.IndexedAttestationBigint;
+    AttesterSlashing: phase0.AttesterSlashing;
+    AggregateAndProof: phase0.AggregateAndProof;
+    SignedAggregateAndProof: phase0.SignedAggregateAndProof;
+    BlockContents: {block: capella.BeaconBlock};
+    SignedBlockContents: {signedBlock: capella.SignedBeaconBlock};
+  };
+  [ForkName.deneb]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: deneb.BeaconBlock;
+    BeaconBlockBody: deneb.BeaconBlockBody;
+    BeaconState: deneb.BeaconState;
+    SignedBeaconBlock: deneb.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    Status: phase0.Status;
+    LightClientHeader: deneb.LightClientHeader;
+    LightClientBootstrap: deneb.LightClientBootstrap;
+    LightClientUpdate: deneb.LightClientUpdate;
+    LightClientFinalityUpdate: deneb.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: deneb.LightClientOptimisticUpdate;
+    LightClientStore: deneb.LightClientStore;
+    BlindedBeaconBlock: deneb.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: deneb.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: deneb.SignedBlindedBeaconBlock;
+    ExecutionPayload: deneb.ExecutionPayload;
+    ExecutionPayloadHeader: deneb.ExecutionPayloadHeader;
+    BuilderBid: deneb.BuilderBid;
+    SignedBuilderBid: deneb.SignedBuilderBid;
+    SSEPayloadAttributes: deneb.SSEPayloadAttributes;
+    BlockContents: deneb.BlockContents;
+    SignedBlockContents: deneb.SignedBlockContents;
+    ExecutionPayloadAndBlobsBundle: deneb.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: deneb.BlobsBundle;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: phase0.Attestation;
+    Attestation: phase0.Attestation;
+    IndexedAttestation: phase0.IndexedAttestation;
+    IndexedAttestationBigint: phase0.IndexedAttestationBigint;
+    AttesterSlashing: phase0.AttesterSlashing;
+    AggregateAndProof: phase0.AggregateAndProof;
+    SignedAggregateAndProof: phase0.SignedAggregateAndProof;
+  };
+  [ForkName.electra]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: electra.BeaconBlock;
+    BeaconBlockBody: electra.BeaconBlockBody;
+    BeaconState: electra.BeaconState;
+    SignedBeaconBlock: electra.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    Status: phase0.Status;
+    LightClientHeader: deneb.LightClientHeader;
+    LightClientBootstrap: electra.LightClientBootstrap;
+    LightClientUpdate: electra.LightClientUpdate;
+    LightClientFinalityUpdate: electra.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: electra.LightClientOptimisticUpdate;
+    LightClientStore: electra.LightClientStore;
+    BlindedBeaconBlock: electra.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: electra.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: electra.SignedBlindedBeaconBlock;
+    ExecutionPayload: deneb.ExecutionPayload;
+    ExecutionPayloadHeader: deneb.ExecutionPayloadHeader;
+    BuilderBid: electra.BuilderBid;
+    SignedBuilderBid: electra.SignedBuilderBid;
+    SSEPayloadAttributes: electra.SSEPayloadAttributes;
+    BlockContents: electra.BlockContents;
+    SignedBlockContents: electra.SignedBlockContents;
+    ExecutionPayloadAndBlobsBundle: deneb.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: deneb.BlobsBundle;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: electra.SingleAttestation;
+    Attestation: electra.Attestation;
+    IndexedAttestation: electra.IndexedAttestation;
+    IndexedAttestationBigint: electra.IndexedAttestationBigint;
+    AttesterSlashing: electra.AttesterSlashing;
+    AggregateAndProof: electra.AggregateAndProof;
+    SignedAggregateAndProof: electra.SignedAggregateAndProof;
+    ExecutionRequests: electra.ExecutionRequests;
+  };
+  [ForkName.fulu]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: electra.BeaconBlock;
+    BeaconBlockBody: electra.BeaconBlockBody;
+    BeaconState: fulu.BeaconState;
+    SignedBeaconBlock: electra.SignedBeaconBlock;
+    Metadata: fulu.Metadata;
+    Status: fulu.Status;
+    LightClientHeader: deneb.LightClientHeader;
+    LightClientBootstrap: electra.LightClientBootstrap;
+    LightClientUpdate: electra.LightClientUpdate;
+    LightClientFinalityUpdate: electra.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: electra.LightClientOptimisticUpdate;
+    LightClientStore: electra.LightClientStore;
+    BlindedBeaconBlock: electra.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: electra.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: electra.SignedBlindedBeaconBlock;
+    ExecutionPayload: deneb.ExecutionPayload;
+    ExecutionPayloadHeader: deneb.ExecutionPayloadHeader;
+    BuilderBid: electra.BuilderBid;
+    SignedBuilderBid: electra.SignedBuilderBid;
+    SSEPayloadAttributes: electra.SSEPayloadAttributes;
+    BlockContents: fulu.BlockContents;
+    SignedBlockContents: fulu.SignedBlockContents;
+    ExecutionPayloadAndBlobsBundle: deneb.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: fulu.BlobsBundle;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: electra.SingleAttestation;
+    Attestation: electra.Attestation;
+    IndexedAttestation: electra.IndexedAttestation;
+    IndexedAttestationBigint: electra.IndexedAttestationBigint;
+    AttesterSlashing: electra.AttesterSlashing;
+    AggregateAndProof: electra.AggregateAndProof;
+    SignedAggregateAndProof: electra.SignedAggregateAndProof;
+    ExecutionRequests: electra.ExecutionRequests;
+  };
+  [ForkName.gloas]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: gloas.BeaconBlock;
+    BeaconBlockBody: gloas.BeaconBlockBody;
+    BeaconState: gloas.BeaconState;
+    SignedBeaconBlock: gloas.SignedBeaconBlock;
+    Metadata: fulu.Metadata;
+    Status: fulu.Status;
+    LightClientHeader: deneb.LightClientHeader;
+    LightClientBootstrap: electra.LightClientBootstrap;
+    LightClientUpdate: electra.LightClientUpdate;
+    LightClientFinalityUpdate: electra.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: electra.LightClientOptimisticUpdate;
+    LightClientStore: electra.LightClientStore;
+    BlindedBeaconBlock: electra.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: electra.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: electra.SignedBlindedBeaconBlock;
+    ExecutionPayload: deneb.ExecutionPayload;
+    ExecutionPayloadHeader: deneb.ExecutionPayloadHeader;
+    BuilderBid: electra.BuilderBid;
+    SignedBuilderBid: electra.SignedBuilderBid;
+    SSEPayloadAttributes: electra.SSEPayloadAttributes;
+    BlockContents: fulu.BlockContents;
+    SignedBlockContents: fulu.SignedBlockContents;
+    ExecutionPayloadAndBlobsBundle: deneb.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: fulu.BlobsBundle;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+    SingleAttestation: electra.SingleAttestation;
+    Attestation: electra.Attestation;
+    IndexedAttestation: electra.IndexedAttestation;
+    IndexedAttestationBigint: electra.IndexedAttestationBigint;
+    AttesterSlashing: electra.AttesterSlashing;
+    AggregateAndProof: electra.AggregateAndProof;
+    SignedAggregateAndProof: electra.SignedAggregateAndProof;
+    ExecutionRequests: electra.ExecutionRequests;
+  };
+};
+
+export type TypesFor<F extends ForkName, K extends keyof TypesByFork[F] | void = void> = K extends void
+  ? TypesByFork[F]
+  : TypesByFork[F][Exclude<K, void>];
+
+export type BeaconBlockHeader<F extends ForkAll = ForkAll> = TypesByFork[F]["BeaconBlockHeader"];
+export type SignedBeaconBlockHeader<F extends ForkAll = ForkAll> = TypesByFork[F]["SignedBeaconBlockHeader"];
+
+export type BeaconBlock<F extends ForkAll = ForkAll> = TypesByFork[F]["BeaconBlock"];
+export type BlindedBeaconBlock<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["BlindedBeaconBlock"];
+
+export type SignedBeaconBlock<F extends ForkAll = ForkAll> = TypesByFork[F]["SignedBeaconBlock"];
+export type SignedBlindedBeaconBlock<F extends ForkPostBellatrix = ForkPostBellatrix> =
+  TypesByFork[F]["SignedBlindedBeaconBlock"];
+
+export type BeaconBlockBody<F extends ForkAll = ForkAll> = TypesByFork[F]["BeaconBlockBody"];
+export type BlindedBeaconBlockBody<F extends ForkPostBellatrix = ForkPostBellatrix> =
+  TypesByFork[F]["BlindedBeaconBlockBody"];
+
+export type BlockContents<F extends ForkAll = ForkAll> = TypesByFork[F]["BlockContents"];
+export type SignedBlockContents<F extends ForkAll = ForkAll> = TypesByFork[F]["SignedBlockContents"];
+export type SignedOrUnsignedBlockContents<F extends ForkAll = ForkAll> = BlockContents<F> | SignedBlockContents<F>;
+
+export type ExecutionPayload<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["ExecutionPayload"];
+export type ExecutionPayloadHeader<F extends ForkPostBellatrix = ForkPostBellatrix> =
+  TypesByFork[F]["ExecutionPayloadHeader"];
+export type ExecutionRequests<F extends ForkPostElectra = ForkPostElectra> = TypesByFork[F]["ExecutionRequests"];
+
+export type ExecutionPayloadAndBlobsBundle<F extends ForkPostDeneb = ForkPostDeneb> =
+  TypesByFork[F]["ExecutionPayloadAndBlobsBundle"];
+export type BlobsBundle<F extends ForkPostDeneb = ForkPostDeneb> = TypesByFork[F]["BlobsBundle"];
+
+export type LightClientHeader<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientHeader"];
+export type LightClientBootstrap<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientBootstrap"];
+export type LightClientUpdate<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientUpdate"];
+export type LightClientFinalityUpdate<F extends ForkPostAltair = ForkPostAltair> =
+  TypesByFork[F]["LightClientFinalityUpdate"];
+export type LightClientOptimisticUpdate<F extends ForkPostAltair = ForkPostAltair> =
+  TypesByFork[F]["LightClientOptimisticUpdate"];
+export type LightClientStore<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["LightClientStore"];
+export type SyncCommittee<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["SyncCommittee"];
+export type SyncAggregate<F extends ForkPostAltair = ForkPostAltair> = TypesByFork[F]["SyncAggregate"];
+
+export type BeaconState<F extends ForkName = ForkAll> = TypesByFork[F]["BeaconState"];
+
+export type Metadata<F extends ForkName = ForkAll> = TypesByFork[F]["Metadata"];
+export type Status<F extends ForkName = ForkAll> = TypesByFork[F]["Status"];
+
+export type BuilderBid<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["BuilderBid"];
+export type SignedBuilderBid<F extends ForkPostBellatrix = ForkPostBellatrix> = TypesByFork[F]["SignedBuilderBid"];
+export type SSEPayloadAttributes<F extends ForkPostBellatrix = ForkPostBellatrix> =
+  TypesByFork[F]["SSEPayloadAttributes"];
+
+export type Attestation<F extends ForkName = ForkAll> = TypesByFork[F]["Attestation"];
+export type SingleAttestation<F extends ForkName = ForkAll> = TypesByFork[F]["SingleAttestation"];
+export type IndexedAttestation<F extends ForkName = ForkAll> = TypesByFork[F]["IndexedAttestation"];
+export type IndexedAttestationBigint<F extends ForkName = ForkAll> = TypesByFork[F]["IndexedAttestationBigint"];
+export type AttesterSlashing<F extends ForkName = ForkAll> = TypesByFork[F]["AttesterSlashing"];
+export type AggregateAndProof<F extends ForkName = ForkAll> = TypesByFork[F]["AggregateAndProof"];
+export type SignedAggregateAndProof<F extends ForkName = ForkAll> = TypesByFork[F]["SignedAggregateAndProof"];

package/src/utils/container.ts

@@ -0,0 +1,38 @@
+import {CompositeTypeAny, CompositeViewDU, ContainerType, Type} from "@chainsafe/ssz";
+
+type BytesRange = {start: number; end: number};
+
+/**
+ * Deserialize a state from bytes ignoring some fields.
+ */
+export function deserializeContainerIgnoreFields<Fields extends Record<string, Type<unknown>>>(
+  sszType: ContainerType<Fields>,
+  bytes: Uint8Array,
+  ignoreFields: (keyof Fields)[],
+  fieldRanges?: BytesRange[]
+): CompositeViewDU<typeof sszType> {
+  const allFields = Object.keys(sszType.fields);
+  const object = sszType.defaultViewDU();
+  if (!fieldRanges) {
+    const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    fieldRanges = sszType.getFieldRanges(dataView, 0, bytes.length);
+  }
+
+  for (const [field, type] of Object.entries(sszType.fields)) {
+    // loaded above
+    if (ignoreFields.includes(field)) {
+      continue;
+    }
+    const fieldIndex = allFields.indexOf(field);
+    const fieldRange = fieldRanges[fieldIndex];
+    if (type.isBasic) {
+      object[field as keyof Fields] = type.deserialize(bytes.subarray(fieldRange.start, fieldRange.end)) as never;
+    } else {
+      object[field as keyof Fields] = (type as CompositeTypeAny).deserializeToViewDU(
+        bytes.subarray(fieldRange.start, fieldRange.end)
+      ) as never;
+    }
+  }
+
+  return object;
+}

package/src/utils/executionAddress.ts

@@ -0,0 +1,48 @@
+import {keccak256} from "ethereum-cryptography/keccak.js";
+import {ByteVectorType} from "@chainsafe/ssz";
+
+export type ByteVector = Uint8Array;
+
+export class ExecutionAddressType extends ByteVectorType {
+  constructor() {
+    super(20, {typeName: "ExecutionAddress"});
+  }
+  toJson(value: ByteVector): unknown {
+    const str = super.toJson(value) as string;
+    return toChecksumAddress(str);
+  }
+}
+
+function isAddressValid(address: string): boolean {
+  return /^(0x)?[0-9a-f]{40}$/i.test(address);
+}
+
+/**
+ * Formats an address according to [ERC55](https://eips.ethereum.org/EIPS/eip-55)
+ */
+export function toChecksumAddress(address: string): string {
+  if (!isAddressValid(address)) {
+    throw Error(`Invalid address: ${address}`);
+  }
+
+  const rawAddress = (address.startsWith("0x") ? address.slice(2) : address).toLowerCase();
+  const chars = rawAddress.split("");
+
+  // Inspired by https://github.com/ethers-io/ethers.js/blob/cac1da1f912c2ae9ba20f25aa51a91766673cd76/src.ts/address/address.ts#L8
+  const expanded = new Uint8Array(chars.length);
+  for (let i = 0; i < expanded.length; i++) {
+    expanded[i] = rawAddress[i].charCodeAt(0);
+  }
+
+  const hashed = keccak256(expanded);
+  for (let i = 0; i < chars.length; i += 2) {
+    if (hashed[i >> 1] >> 4 >= 8) {
+      chars[i] = chars[i].toUpperCase();
+    }
+    if ((hashed[i >> 1] & 0x0f) >= 8) {
+      chars[i + 1] = chars[i + 1].toUpperCase();
+    }
+  }
+
+  return "0x" + chars.join("");
+}