Bump SSZ to v0.9.0

package.json

@@ -18,8 +18,8 @@
     "lint": "lerna run lint --no-bail",
     "check-types": "lerna run check-types --no-bail",
     "coverage": "lerna run coverage --no-bail",
-    "test:unit": "lerna run test:unit --no-bail",
-    "test:e2e": "lerna run test:e2e --no-bail",
+    "test:unit": "lerna run test:unit --no-bail --concurrency 1",
+    "test:e2e": "lerna run test:e2e --no-bail --concurrency 1",
     "test:e2e:sim": "lerna run test:e2e:sim --no-bail",
     "test:spec-min": "lerna run test:spec-min --no-bail",
     "test:spec-fast": "lerna run test:spec-fast --no-bail",

packages/api/package.json

@@ -40,8 +40,8 @@
     "@chainsafe/lodestar-params": "^0.35.0",
     "@chainsafe/lodestar-types": "^0.35.0",
     "@chainsafe/lodestar-utils": "^0.35.0",
-    "@chainsafe/persistent-merkle-tree": "^0.3.7",
-    "@chainsafe/ssz": "^0.8.20",
+    "@chainsafe/persistent-merkle-tree": "https://gitpkg.now.sh/dapplion/ssz/packages/persistent-merkle-tree?dapplion/v2",
+    "@chainsafe/ssz": "https://gitpkg.now.sh/dapplion/ssz/packages/ssz?e01ce05824485c0045fb2d1fb99cd1e898f49af2",
     "cross-fetch": "^3.1.4",
     "eventsource": "^1.1.0",
     "qs": "^6.10.1"

packages/api/src/client/utils/client.ts

@@ -1,4 +1,3 @@
-import {Json} from "@chainsafe/ssz";
 import {mapValues} from "@chainsafe/lodestar-utils";
 import {FetchOpts, IHttpClient} from "./httpClient";
 import {compileRouteUrlFormater} from "../../utils/urlFormat";
@@ -8,7 +7,6 @@ import {
   RouteGeneric,
   ReturnTypes,
   TypeJson,
-  jsonOpts,
   ReqSerializer,
   ReqSerializers,
   RoutesData,
@@ -69,10 +67,10 @@ export function generateGenericJsonClient<
     const returnType = returnTypes[routeKey as keyof ReturnTypes<Api>] as TypeJson<any> | null;
 
     return async function request(...args: Parameters<Api[keyof Api]>): Promise<any | void> {
-      const res = await fetchFn.json<Json>(fetchOptsSerializer(...args));
+      const res = await fetchFn.json<unknown>(fetchOptsSerializer(...args));
       if (returnType) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return returnType.fromJson(res, jsonOpts) as ReturnType<Api[keyof Api]>;
+        return returnType.fromJson(res) as ReturnType<Api[keyof Api]>;
       }
     };
   }) as Api;

packages/api/src/routes/beacon/block.ts

@@ -1,4 +1,4 @@
-import {ContainerType, Json} from "@chainsafe/ssz";
+import {ContainerType} from "@chainsafe/ssz";
 import {ForkName} from "@chainsafe/lodestar-params";
 import {IChainForkConfig} from "@chainsafe/lodestar-config";
 import {phase0, allForks, Slot, Root, ssz} from "@chainsafe/lodestar-types";
@@ -114,7 +114,7 @@ export type ReqTypes = {
   getBlockHeader: BlockIdOnlyReq;
   getBlockHeaders: {query: {slot?: number; parent_root?: string}};
   getBlockRoot: BlockIdOnlyReq;
-  publishBlock: {body: Json};
+  publishBlock: {body: unknown};
 };
 
 export function getReqSerializers(config: IChainForkConfig): ReqSerializers<Api, ReqTypes> {
@@ -125,12 +125,12 @@ export function getReqSerializers(config: IChainForkConfig): ReqSerializers<Api,
   };
 
   // Compute block type from JSON payload. See https://github.com/ethereum/eth2.0-APIs/pull/142
-  const getSignedBeaconBlockType = (data: allForks.SignedBeaconBlock): ContainerType<allForks.SignedBeaconBlock> =>
+  const getSignedBeaconBlockType = (data: allForks.SignedBeaconBlock): allForks.AllForksSSZTypes["SignedBeaconBlock"] =>
     config.getForkTypes(data.message.slot).SignedBeaconBlock;
+
   const AllForksSignedBeaconBlock: TypeJson<allForks.SignedBeaconBlock> = {
-    toJson: (data, opts) => getSignedBeaconBlockType(data).toJson(data, opts),
-    fromJson: (data, opts) =>
-      getSignedBeaconBlockType((data as unknown) as allForks.SignedBeaconBlock).fromJson(data, opts),
+    toJson: (data) => getSignedBeaconBlockType(data).toJson(data),
+    fromJson: (data) => getSignedBeaconBlockType((data as unknown) as allForks.SignedBeaconBlock).fromJson(data),
   };
 
   return {
@@ -149,14 +149,10 @@ export function getReqSerializers(config: IChainForkConfig): ReqSerializers<Api,
 }
 
 export function getReturnTypes(): ReturnTypes<Api> {
-  const BeaconHeaderResType = new ContainerType<BlockHeaderResponse>({
-    fields: {
-      root: ssz.Root,
-      canonical: ssz.Boolean,
-      header: ssz.phase0.SignedBeaconBlockHeader,
-    },
-    //from beacon apis
-    expectedCase: "notransform",
+  const BeaconHeaderResType = new ContainerType({
+    root: ssz.Root,
+    canonical: ssz.Boolean,
+    header: ssz.phase0.SignedBeaconBlockHeader,
   });
 
   return {

packages/api/src/routes/beacon/pool.ts

@@ -1,5 +1,4 @@
 import {phase0, altair, CommitteeIndex, Slot, ssz} from "@chainsafe/lodestar-types";
-import {Json} from "@chainsafe/ssz";
 import {
   RoutesData,
   ReturnTypes,
@@ -122,11 +121,11 @@ export type ReqTypes = {
   getPoolAttesterSlashings: ReqEmpty;
   getPoolProposerSlashings: ReqEmpty;
   getPoolVoluntaryExits: ReqEmpty;
-  submitPoolAttestations: {body: Json};
-  submitPoolAttesterSlashing: {body: Json};
-  submitPoolProposerSlashing: {body: Json};
-  submitPoolVoluntaryExit: {body: Json};
-  submitPoolSyncCommitteeSignatures: {body: Json};
+  submitPoolAttestations: {body: unknown};
+  submitPoolAttesterSlashing: {body: unknown};
+  submitPoolProposerSlashing: {body: unknown};
+  submitPoolVoluntaryExit: {body: unknown};
+  submitPoolSyncCommitteeSignatures: {body: unknown};
 };
 
 export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {

packages/api/src/routes/beacon/state.ts

@@ -217,54 +217,49 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
 
 /* eslint-disable @typescript-eslint/naming-convention */
 export function getReturnTypes(): ReturnTypes<Api> {
-  const FinalityCheckpoints = new ContainerType<FinalityCheckpoints>({
-    fields: {
+  const FinalityCheckpoints = new ContainerType(
+    {
       previousJustified: ssz.phase0.Checkpoint,
       currentJustified: ssz.phase0.Checkpoint,
       finalized: ssz.phase0.Checkpoint,
     },
-    // From beacon apis
-    casingMap: {
-      previousJustified: "previous_justified",
-      currentJustified: "current_justified",
-      finalized: "finalized",
-    },
-  });
+    {jsonCase: "eth2"}
+  );
 
-  const ValidatorResponse = new ContainerType<ValidatorResponse>({
-    fields: {
+  const ValidatorResponse = new ContainerType(
+    {
       index: ssz.ValidatorIndex,
-      balance: ssz.Number64,
+      balance: ssz.UintNum64,
       status: new StringType<ValidatorStatus>(),
       validator: ssz.phase0.Validator,
     },
-    // From beacon apis
-    expectedCase: "notransform",
-  });
+    {jsonCase: "eth2"}
+  );
 
-  const ValidatorBalance = new ContainerType<ValidatorBalance>({
-    fields: {
+  const ValidatorBalance = new ContainerType(
+    {
       index: ssz.ValidatorIndex,
-      balance: ssz.Number64,
+      balance: ssz.UintNum64,
     },
-    // From beacon apis
-    expectedCase: "notransform",
-  });
+    {jsonCase: "eth2"}
+  );
 
-  const EpochCommitteeResponse = new ContainerType<EpochCommitteeResponse>({
-    fields: {
+  const EpochCommitteeResponse = new ContainerType(
+    {
       index: ssz.CommitteeIndex,
       slot: ssz.Slot,
       validators: ssz.phase0.CommitteeIndices,
     },
-  });
+    {jsonCase: "eth2"}
+  );
 
-  const EpochSyncCommitteesResponse = new ContainerType<EpochSyncCommitteeResponse>({
-    fields: {
+  const EpochSyncCommitteesResponse = new ContainerType(
+    {
       validators: ArrayOf(ssz.ValidatorIndex),
       validatorAggregates: ArrayOf(ssz.ValidatorIndex),
     },
-  });
+    {jsonCase: "eth2"}
+  );
 
   return {
     getStateRoot: ContainerData(ssz.Root),

packages/api/src/routes/config.ts

@@ -1,14 +1,14 @@
 import {BeaconPreset} from "@chainsafe/lodestar-params";
 import {IChainConfig} from "@chainsafe/lodestar-config";
-import {Bytes32, Number64, phase0, ssz} from "@chainsafe/lodestar-types";
+import {Bytes32, UintNum64, phase0, ssz} from "@chainsafe/lodestar-types";
 import {mapValues} from "@chainsafe/lodestar-utils";
 import {ByteVectorType, ContainerType} from "@chainsafe/ssz";
 import {ArrayOf, ContainerData, ReqEmpty, reqEmpty, ReturnTypes, ReqSerializers, RoutesData, sameType} from "../utils";
 
 // See /packages/api/src/routes/index.ts for reasoning and instructions to add new routes
 
 export type DepositContract = {
-  chainId: Number64;
+  chainId: UintNum64;
   address: Bytes32;
 };
 
@@ -57,17 +57,13 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
 
 /* eslint-disable @typescript-eslint/naming-convention */
 export function getReturnTypes(): ReturnTypes<Api> {
-  const DepositContract = new ContainerType<DepositContract>({
-    fields: {
-      chainId: ssz.Number64,
-      address: new ByteVectorType({length: 20}),
+  const DepositContract = new ContainerType(
+    {
+      chainId: ssz.UintNum64,
+      address: new ByteVectorType(20),
     },
-    // From beacon apis
-    casingMap: {
-      chainId: "chain_id",
-      address: "address",
-    },
-  });
+    {jsonCase: "eth2"}
+  );
 
   return {
     getDepositContract: ContainerData(DepositContract),

packages/api/src/routes/debug.ts

@@ -115,14 +115,13 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
 /* eslint-disable @typescript-eslint/naming-convention */
 export function getReturnTypes(): ReturnTypes<Api> {
   const stringType = new StringType();
-  const SlotRoot = new ContainerType<SlotRoot>({
-    fields: {
+  const SlotRoot = new ContainerType(
+    {
       slot: ssz.Slot,
       root: stringType,
     },
-    // From beacon apis
-    expectedCase: "notransform",
-  });
+    {jsonCase: "eth2"}
+  );
 
   return {
     getHeads: ContainerData(ArrayOf(SlotRoot)),

packages/api/src/routes/events.ts

@@ -1,6 +1,6 @@
-import {Epoch, Number64, phase0, Slot, ssz, StringType, RootHex, altair} from "@chainsafe/lodestar-types";
-import {ContainerType, Json, Type} from "@chainsafe/ssz";
-import {jsonOpts, RouteDef, TypeJson} from "../utils";
+import {Epoch, phase0, Slot, ssz, StringType, RootHex, altair, UintNum64} from "@chainsafe/lodestar-types";
+import {ContainerType, Type} from "@chainsafe/ssz";
+import {RouteDef, TypeJson} from "../utils";
 
 // See /packages/api/src/routes/index.ts for reasoning and instructions to add new routes
 
@@ -46,7 +46,7 @@ export type EventData = {
   [EventType.finalizedCheckpoint]: {block: RootHex; state: RootHex; epoch: Epoch};
   [EventType.chainReorg]: {
     slot: Slot;
-    depth: Number64;
+    depth: UintNum64;
     oldHeadBlock: RootHex;
     newHeadBlock: RootHex;
     oldHeadState: RootHex;
@@ -87,80 +87,58 @@ export type ReqTypes = {
 export function getTypeByEvent(): {[K in EventType]: Type<EventData[K]>} {
   const stringType = new StringType();
   return {
-    [EventType.head]: new ContainerType<EventData[EventType.head]>({
-      fields: {
+    [EventType.head]: new ContainerType(
+      {
         slot: ssz.Slot,
         block: stringType,
         state: stringType,
         epochTransition: ssz.Boolean,
         previousDutyDependentRoot: stringType,
         currentDutyDependentRoot: stringType,
       },
-      // From beacon apis eventstream
-      casingMap: {
-        slot: "slot",
-        block: "block",
-        state: "state",
-        epochTransition: "epoch_transition",
-        previousDutyDependentRoot: "previous_duty_dependent_root",
-        currentDutyDependentRoot: "current_duty_dependent_root",
-      },
-    }),
+      {jsonCase: "eth2"}
+    ),
 
-    [EventType.block]: new ContainerType<EventData[EventType.block]>({
-      fields: {
+    [EventType.block]: new ContainerType(
+      {
         slot: ssz.Slot,
         block: stringType,
       },
-      // From beacon apis eventstream
-      expectedCase: "notransform",
-    }),
+      {jsonCase: "eth2"}
+    ),
 
     [EventType.attestation]: ssz.phase0.Attestation,
     [EventType.voluntaryExit]: ssz.phase0.SignedVoluntaryExit,
 
-    [EventType.finalizedCheckpoint]: new ContainerType<EventData[EventType.finalizedCheckpoint]>({
-      fields: {
+    [EventType.finalizedCheckpoint]: new ContainerType(
+      {
         block: stringType,
         state: stringType,
         epoch: ssz.Epoch,
       },
-      // From beacon apis eventstream
-      expectedCase: "notransform",
-    }),
+      {jsonCase: "eth2"}
+    ),
 
-    [EventType.chainReorg]: new ContainerType<EventData[EventType.chainReorg]>({
-      fields: {
+    [EventType.chainReorg]: new ContainerType(
+      {
         slot: ssz.Slot,
-        depth: ssz.Number64,
+        depth: ssz.UintNum64,
         oldHeadBlock: stringType,
         newHeadBlock: stringType,
         oldHeadState: stringType,
         newHeadState: stringType,
         epoch: ssz.Epoch,
       },
-      // From beacon apis eventstream
-      casingMap: {
-        slot: "slot",
-        depth: "depth",
-        oldHeadBlock: "old_head_block",
-        newHeadBlock: "new_head_block",
-        oldHeadState: "old_head_state",
-        newHeadState: "new_head_state",
-        epoch: "epoch",
-      },
-    }),
+      {jsonCase: "eth2"}
+    ),
 
-    [EventType.lightclientHeaderUpdate]: new ContainerType<EventData[EventType.lightclientHeaderUpdate]>({
-      fields: {
+    [EventType.lightclientHeaderUpdate]: new ContainerType(
+      {
         syncAggregate: ssz.altair.SyncAggregate,
         attestedHeader: ssz.phase0.BeaconBlockHeader,
       },
-      casingMap: {
-        syncAggregate: "sync_aggregate",
-        attestedHeader: "attested_header",
-      },
-    }),
+      {jsonCase: "eth2"}
+    ),
   };
 }
 
@@ -169,13 +147,13 @@ export function getEventSerdes() {
   const typeByEvent = getTypeByEvent();
 
   return {
-    toJson: (event: BeaconEvent): Json => {
+    toJson: (event: BeaconEvent): unknown => {
       const eventType = typeByEvent[event.type] as TypeJson<BeaconEvent["message"]>;
-      return eventType.toJson(event.message, jsonOpts);
+      return eventType.toJson(event.message);
     },
-    fromJson: (type: EventType, data: Json): BeaconEvent["message"] => {
+    fromJson: (type: EventType, data: unknown): BeaconEvent["message"] => {
       const eventType = typeByEvent[type] as TypeJson<BeaconEvent["message"]>;
-      return eventType.fromJson(data, jsonOpts);
+      return eventType.fromJson(data);
     },
   };
 }