@lodestar/state-transition 1.40.0-dev.9defa5c09b → 1.40.0-dev.ade3accfa0

package/src/util/loadState/findModifiedInactivityScores.ts

@@ -1,9 +1,11 @@
+import {byteArrayEquals} from "@lodestar/utils";
+
 // UintNum64 = 8 bytes
 export const INACTIVITY_SCORE_SIZE = 8;
 
 /**
  * As monitored on mainnet, inactivityScores are not changed much and they are mostly 0
- * Using Buffer.compare is the fastest way as noted in `./findModifiedValidators.ts`
+ * Using byteArrayEquals is the optimal way as noted in `./findModifiedValidators.ts`
  * @returns output parameter modifiedValidators: validator indices that are modified
  */
 export function findModifiedInactivityScores(
@@ -21,7 +23,7 @@ export function findModifiedInactivityScores(
     );
   }
 
-  if (Buffer.compare(inactivityScoresBytes, inactivityScoresBytes2) === 0) {
+  if (byteArrayEquals(inactivityScoresBytes, inactivityScoresBytes2)) {
     return;
   }
 

package/src/util/loadState/findModifiedValidators.ts

@@ -1,10 +1,11 @@
+import {byteArrayEquals} from "@lodestar/utils";
 import {VALIDATOR_BYTES_SIZE} from "../sszBytes.js";
 
 /**
- * Find modified validators by comparing two validators bytes using Buffer.compare() recursively
+ * Find modified validators by comparing two validators bytes using byteArrayEquals() recursively
  * - As noted in packages/state-transition/test/perf/util/loadState/findModifiedValidators.test.ts, serializing validators and compare Uint8Array is the fastest way
  * - The performance is quite stable and can afford a lot of difference in validators (the benchmark tested up to 10k but it's not likely we have that difference in mainnet)
- * - Also packages/state-transition/test/perf/misc/byteArrayEquals.test.ts shows that Buffer.compare() is very efficient for large Uint8Array
+ * - byteArrayEquals() uses the optimal comparison method based on array size
  *
  * @returns output parameter modifiedValidators: validator indices that are modified
  */
@@ -20,7 +21,7 @@ export function findModifiedValidators(
     );
   }
 
-  if (Buffer.compare(validatorsBytes, validatorsBytes2) === 0) {
+  if (byteArrayEquals(validatorsBytes, validatorsBytes2)) {
     return;
   }
 

package/src/util/loadState/loadValidator.ts

@@ -1,6 +1,7 @@
 import {CompositeViewDU} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {ValidatorIndex, deserializeContainerIgnoreFields, ssz} from "@lodestar/types";
+import {byteArrayEquals} from "@lodestar/utils";
 import {getStateTypeFromBytes} from "../sszBytes.js";
 
 /**
@@ -32,12 +33,12 @@ function getSameFields(
 ): ("pubkey" | "withdrawalCredentials")[] {
   const ignoredFields: ("pubkey" | "withdrawalCredentials")[] = [];
   const pubkey = validatorBytes.subarray(0, 48);
-  if (Buffer.compare(pubkey, validator.pubkey) === 0) {
+  if (byteArrayEquals(pubkey, validator.pubkey)) {
     ignoredFields.push("pubkey");
   }
 
   const withdrawalCredentials = validatorBytes.subarray(48, 80);
-  if (Buffer.compare(withdrawalCredentials, validator.withdrawalCredentials) === 0) {
+  if (byteArrayEquals(withdrawalCredentials, validator.withdrawalCredentials)) {
     ignoredFields.push("withdrawalCredentials");
   }
 

package/src/util/signatureSets.ts

@@ -1,11 +1,21 @@
-import {PublicKey, Signature, fastAggregateVerify, verify} from "@chainsafe/blst";
+import {PublicKey, Signature, aggregatePublicKeys, fastAggregateVerify, verify} from "@chainsafe/blst";
 import {Root} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 
 export enum SignatureSetType {
   single = "single",
   aggregate = "aggregate",
+  /**
+   * Single signature with validator index instead of pubkey.
+   * Pubkey lookup is deferred to verification time.
+   */
+  indexed = "indexed",
 }
 
+/**
+ * Single signature with pubkey directly.
+ * Used when pubkey comes from the message itself (e.g. BLS to execution change).
+ */
 export type SingleSignatureSet = {
   type: SignatureSetType.single;
   pubkey: PublicKey;
@@ -13,16 +23,57 @@ export type SingleSignatureSet = {
   signature: Uint8Array;
 };
 
+/**
+ * Single signature with validator index.
+ * Pubkey is looked up at verification time.
+ */
+export type IndexedSignatureSet = {
+  type: SignatureSetType.indexed;
+  index: number;
+  signingRoot: Root;
+  signature: Uint8Array;
+};
+
+/**
+ * Aggregate signature with validator indices.
+ * Pubkeys are looked up and aggregated at verification time.
+ */
 export type AggregatedSignatureSet = {
   type: SignatureSetType.aggregate;
-  pubkeys: PublicKey[];
+  indices: number[];
   signingRoot: Root;
   signature: Uint8Array;
 };
 
-export type ISignatureSet = SingleSignatureSet | AggregatedSignatureSet;
+export type ISignatureSet = SingleSignatureSet | IndexedSignatureSet | AggregatedSignatureSet;
+
+/**
+ * Get the pubkey for a signature set, performing aggregation if necessary.
+ * Requires index2pubkey cache for indexed and aggregate sets.
+ */
+export function getSignatureSetPubkey(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): PublicKey {
+  switch (signatureSet.type) {
+    case SignatureSetType.single:
+      return signatureSet.pubkey;
+
+    case SignatureSetType.indexed:
+      return index2pubkey[signatureSet.index];
+
+    case SignatureSetType.aggregate: {
+      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      return aggregatePublicKeys(pubkeys);
+    }
 
-export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
+    default:
+      throw Error("Unknown signature set type");
+  }
+}
+
+export function verifySignatureSet(signatureSet: SingleSignatureSet, index2pubkey?: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: IndexedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: AggregatedSignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey: Index2PubkeyCache): boolean;
+export function verifySignatureSet(signatureSet: ISignatureSet, index2pubkey?: Index2PubkeyCache): boolean {
   // All signatures are not trusted and must be group checked (p2.subgroup_check)
   const signature = Signature.fromBytes(signatureSet.signature, true);
 
@@ -30,8 +81,20 @@ export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
     case SignatureSetType.single:
       return verify(signatureSet.signingRoot, signatureSet.pubkey, signature);
 
-    case SignatureSetType.aggregate:
-      return fastAggregateVerify(signatureSet.signingRoot, signatureSet.pubkeys, signature);
+    case SignatureSetType.indexed: {
+      if (!index2pubkey) {
+        throw Error("index2pubkey required for indexed signature set");
+      }
+      return verify(signatureSet.signingRoot, index2pubkey[signatureSet.index], signature);
+    }
+
+    case SignatureSetType.aggregate: {
+      if (!index2pubkey) {
+        throw Error("index2pubkey required for aggregate signature set");
+      }
+      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      return fastAggregateVerify(signatureSet.signingRoot, pubkeys, signature);
+    }
 
     default:
       throw Error("Unknown signature set type");
@@ -51,14 +114,27 @@ export function createSingleSignatureSetFromComponents(
   };
 }
 
+export function createIndexedSignatureSetFromComponents(
+  index: number,
+  signingRoot: Root,
+  signature: Uint8Array
+): IndexedSignatureSet {
+  return {
+    type: SignatureSetType.indexed,
+    index,
+    signingRoot,
+    signature,
+  };
+}
+
 export function createAggregateSignatureSetFromComponents(
-  pubkeys: PublicKey[],
+  indices: number[],
   signingRoot: Root,
   signature: Uint8Array
 ): AggregatedSignatureSet {
   return {
     type: SignatureSetType.aggregate,
-    pubkeys,
+    indices,
     signingRoot,
     signature,
   };