Improved Filtering and Selection Logic for Best Tip and Tie Breaker Mechanism

package.json

@@ -49,6 +49,7 @@
     "@graphql-tools/schema": "^9.0.16",
     "@opentelemetry/exporter-jaeger": "^1.9.1",
     "@opentelemetry/tracing": "^0.24.0",
+    "blakejs": "^1.2.1",
     "dotenv": "^16.0.3",
     "graphql": "^16.6.0",
     "graphql-yoga": "3.7.0",

src/db/archive-node-adapter/index.ts

@@ -7,6 +7,7 @@ import {
   Event,
   Events,
   ArchiveNodeDatabaseRow,
+  BlockInfo,
   BlocksWithTransactionsMap,
   FieldElementIdWithValueMap,
 } from '../../models/types';
@@ -30,6 +31,8 @@ import type {
 } from '../../resolvers-types';
 import { TraceInfo } from 'src/tracing';
 
+import { blake2bHex } from 'blakejs';
+
 export class ArchiveNodeAdapter implements DatabaseAdapter {
   private client: postgres.Sql;
 
@@ -95,6 +98,7 @@ export class ArchiveNodeAdapter implements DatabaseAdapter {
       elementIdFieldValues
     );
     eventsData.sort((a, b) => b.blockInfo.height - a.blockInfo.height);
+    filterBestTip(eventsData);
     eventsProcessingSpan?.end();
     return eventsData ?? [];
   }
@@ -128,6 +132,7 @@ export class ArchiveNodeAdapter implements DatabaseAdapter {
       elementIdFieldValues
     );
     actionsData.sort((a, b) => b.blockInfo.height - a.blockInfo.height);
+    filterBestTip(actionsData);
     actionsProcessingSpan?.end();
     return actionsData ?? [];
   }
@@ -369,3 +374,92 @@ function findAllIndexes<T>(arr: T[], target: T): number[] {
   });
   return indexes;
 }
+
+function findLastIndexPredicate<T>(array: T[], predicate: (arg: T) => boolean) {
+  for (let i = 0; i < array.length; i++) {
+    console.log(array[i], predicate(array[i]));
+    if (
+      predicate(array[i]) &&
+      i < array.length - 1 &&
+      !predicate(array[i + 1])
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function getAllPredicate<T>(array: T[], predicate: (arg: T) => boolean) {
+  const data: T[] = [];
+  for (let i = 0; i < array.length; i++) {
+    if (predicate(array[i])) {
+      data.push(array[i]);
+    } else {
+      break;
+    }
+  }
+  return data;
+}
+
+function filterBestTip<T extends { blockInfo: BlockInfo }>(
+  eventOrActionData: T[]
+) {
+  const highestTipBlocks = getAllPredicate(
+    eventOrActionData,
+    (e) => e.blockInfo.distanceFromMaxBlockHeight === 0
+  );
+  if (highestTipBlocks.length > 1) {
+    const index = findLastIndexPredicate(
+      eventOrActionData,
+      (event) => event.blockInfo.distanceFromMaxBlockHeight === 0
+    );
+    if (index === -1) {
+      return eventOrActionData;
+    }
+    const selectedTip = chainSelect(highestTipBlocks);
+    eventOrActionData.splice(0, index + 1);
+    eventOrActionData.unshift(selectedTip);
+  }
+}
+
+function chainSelect<T extends { blockInfo: BlockInfo }>(blocks: T[]) {
+  if (blocks.length === 1) return blocks[0];
+  let existing = blocks[0];
+  for (let i = 1; i < blocks.length; i++) {
+    const candidate = blocks[i];
+    existing = select(existing, candidate);
+  }
+  return existing;
+}
+
+/**
+ * This function is used to select the best chain based on the tie breaker rules that the Mina Protocol uses.
+ *
+ * The tie breaker rules are as follows:
+ * 1. Take the block with the highest VRF output, denoted by comparing the VRF Blake2B hashes.
+ *  - https://github.com/MinaProtocol/mina/blob/bff1e117ae4740fa51d12b32736c6c63d7909bd1/src/lib/consensus/proof_of_stake.ml#L3004
+ * 2. If the VRF outputs are equal, take the block with the highest state hash.
+ *  - https://github.com/MinaProtocol/mina/blob/bff1e117ae4740fa51d12b32736c6c63d7909bd1/src/lib/consensus/proof_of_stake.ml#L3001
+ *
+ * The tie breaker rules are also more formally documented here: https://github.com/MinaProtocol/mina/blob/36d39cd0b2e3ba6c5e687770a5c683984ca587fc/docs/specs/consensus/README.md?plain=1#L1134
+ */
+
+function select<T extends { blockInfo: BlockInfo }>(existing: T, candidate: T) {
+  const existingVRFHash = blake2bHex(existing.blockInfo.lastVrfOutput);
+  const candidateVRFHash = blake2bHex(candidate.blockInfo.lastVrfOutput);
+  if (existingVRFHash > candidateVRFHash) {
+    return existing;
+  } else if (existingVRFHash < candidateVRFHash) {
+    return candidate;
+  }
+
+  const existingHash = existing.blockInfo.stateHash;
+  const candidateHash = candidate.blockInfo.stateHash;
+  if (existingHash > candidateHash) {
+    return existing;
+  } else if (existingHash < candidateHash) {
+    return candidate;
+  }
+
+  return existing;
+}

src/db/archive-node-adapter/queries.ts

@@ -7,15 +7,15 @@ function fullChainCTE(db_client: postgres.Sql) {
   RECURSIVE pending_chain AS (
     (
       SELECT
-        id, state_hash, parent_hash, parent_id, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash
+        id, state_hash, parent_hash, parent_id, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash, last_vrf_output
       FROM
         blocks b
       WHERE
         height = (SELECT max(height) FROM blocks)
     ) 
     UNION ALL
     SELECT
-      b.id, b.state_hash, b.parent_hash, b.parent_id, b.height, b.global_slot_since_genesis, b.global_slot_since_hard_fork, b.timestamp, b.chain_status, b.ledger_hash
+      b.id, b.state_hash, b.parent_hash, b.parent_id, b.height, b.global_slot_since_genesis, b.global_slot_since_hard_fork, b.timestamp, b.chain_status, b.ledger_hash, b.last_vrf_output
     FROM
       blocks b
     INNER JOIN pending_chain ON b.id = pending_chain.parent_id
@@ -24,16 +24,16 @@ function fullChainCTE(db_client: postgres.Sql) {
   ), 
   full_chain AS (
     SELECT
-      DISTINCT id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash, (SELECT max(height) FROM blocks) - height AS distance_from_max_block_height
+      DISTINCT id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash, (SELECT max(height) FROM blocks) - height AS distance_from_max_block_height, last_vrf_output
     FROM
       (
         SELECT
-          id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash
+          id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash, last_vrf_output
         FROM
           pending_chain
         UNION ALL
         SELECT
-          id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash
+          id, state_hash, parent_id, parent_hash, height, global_slot_since_genesis, global_slot_since_hard_fork, timestamp, chain_status, ledger_hash, last_vrf_output
         FROM
           blocks b
         WHERE
@@ -84,7 +84,8 @@ function blocksAccessedCTE(
       timestamp,
       chain_status,
       ledger_hash,
-      distance_from_max_block_height
+      distance_from_max_block_height,
+      last_vrf_output
   FROM
     account_identifier ai
     INNER JOIN accounts_accessed aa ON ai.requesting_zkapp_account_identifier_id = aa.account_identifier_id

src/models/types.ts

@@ -35,6 +35,7 @@ export type BlockInfo = {
   globalSlotSinceHardfork: number;
   globalSlotSinceGenesis: number;
   distanceFromMaxBlockHeight: number;
+  lastVrfOutput: string;
 };
 
 export type TransactionInfo = {
@@ -93,6 +94,7 @@ export type ArchiveNodeDatabaseRow = {
   field: string;
   zkapp_event_element_ids: number[];
   zkapp_event_array_id: number;
+  last_vrf_output: string;
   action_state_value1?: string;
   action_state_value2?: string;
   action_state_value3?: string;

src/models/utils.ts

@@ -17,6 +17,7 @@ export function createBlockInfo(row: ArchiveNodeDatabaseRow) {
     globalSlotSinceHardfork: Number(row.global_slot_since_hard_fork),
     globalSlotSinceGenesis: Number(row.global_slot_since_genesis),
     distanceFromMaxBlockHeight: Number(row.distance_from_max_block_height),
+    lastVrfOutput: row.last_vrf_output,
   } as BlockInfo;
 }