Merge pull request #349 from hack-a-chain-software/orphan-blocks

feat: orphan blocks mechanism

Author: mschead

indexer/src/index.ts

@@ -19,11 +19,10 @@ import { closeDatabase } from './config/database';
 import { initializeDatabase } from './config/init';
 import { startGraphqlServer } from './kadena-server/server';
 import { backfillBalances } from './services/balances';
-import { startMissingBlocks } from './services/missing';
 import { startStreaming } from './services/streaming';
 import { backfillPairEvents } from './services/pair';
 import { setupAssociations } from './models/setup-associations';
-import { PriceUpdaterService } from './services/price/price-updater.service';
+import { PriceUpdaterService } from '@/services/price/price-updater.service';
 
 /**
  * Command-line interface configuration using Commander.
@@ -33,7 +32,6 @@ program
   .option('-s, --streaming', 'Start streaming blockchain data')
   .option('-t, --graphql', 'Start GraphQL server based on kadena schema')
   .option('-f, --guards', 'Backfill the guards')
-  .option('-m, --missing', 'Missing blocks')
   .option('-z, --database', 'Init the database')
   .option('-p, --backfillPairs', 'Backfill the pairs');
 
@@ -58,7 +56,7 @@ const options = program.opts();
 async function main() {
   try {
     setupAssociations();
-    await PriceUpdaterService.getInstance();
+    PriceUpdaterService.getInstance();
 
     if (options.database) {
       await initializeDatabase();
@@ -72,20 +70,16 @@ async function main() {
       await backfillBalances();
       await closeDatabase();
       process.exit(0);
-    } else if (options.missing) {
-      await startMissingBlocks();
-      process.exit(0);
     } else if (options.graphql) {
       await startGraphqlServer();
     } else if (options.backfillPairs) {
-      PriceUpdaterService.getInstance();
       await backfillPairEvents();
     } else {
       console.info('[INFO][BIZ][BIZ_FLOW] No specific task requested.');
     }
   } catch (error) {
     console.error('[ERROR][INFRA][INFRA_CONFIG] Initialization failed:', error);
-    // TODO: [OPTIMIZATION] Implement more detailed error logging and possibly retry mechanisms
+    process.exit(1);
   }
 }
 

indexer/src/kadena-server/config/graphql-types.ts

@@ -30,6 +30,7 @@ export type Scalars = {
 /** A unit of information that stores a set of verified transactions. */
 export type Block = Node & {
   __typename?: 'Block';
+  canonical: Scalars['Boolean']['output'];
   chainId: Scalars['BigInt']['output'];
   coinbase: Scalars['String']['output'];
   creationTime: Scalars['DateTime']['output'];
@@ -1983,6 +1984,7 @@ export type BlockResolvers<
   ContextType = any,
   ParentType extends ResolversParentTypes['Block'] = ResolversParentTypes['Block'],
 > = {
+  canonical?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
   chainId?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
   coinbase?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   creationTime?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;

indexer/src/kadena-server/config/schema.graphql

@@ -620,6 +620,8 @@ type Block implements Node {
   """
   powHash: String!
 
+  canonical: Boolean!
+
   parent: Block @complexity(value: 1)
   """
   Default page size is 20.

indexer/src/kadena-server/repository/application/block-repository.ts

@@ -26,9 +26,14 @@ export interface GetLatestBlocksParams {
   chainIds?: string[];
 }
 
+export interface UpdateCanonicalStatusParams {
+  blocks: { hash: string; canonical: boolean }[];
+}
+
 export type BlockOutput = Omit<Block, 'parent' | 'events' | 'minerAccount' | 'transactions'> & {
   parentHash: string;
   blockId: number;
+  canonical: boolean;
 };
 
 export type FungibleChainAccountOutput = Omit<
@@ -37,7 +42,7 @@ export type FungibleChainAccountOutput = Omit<
 >;
 
 export default interface BlockRepository {
-  getBlockByHash(hash: string): Promise<BlockOutput>;
+  getBlockByHash(hash: string): Promise<BlockOutput | null>;
   getBlocksFromDepth(params: GetBlocksFromDepthParams): Promise<{
     pageInfo: PageInfo;
     edges: ConnectionEdge<BlockOutput>[];
@@ -75,6 +80,11 @@ export default interface BlockRepository {
     id?: string,
   ): Promise<BlockOutput[]>;
 
+  getBlockNParent(depth: number, hash: string): Promise<string | undefined>;
+  getBlocksWithSameHeight(height: number, chainId: string): Promise<BlockOutput[]>;
+  getBlocksWithHeightHigherThan(height: number, chainId: string): Promise<BlockOutput[]>;
+  updateCanonicalStatus(params: UpdateCanonicalStatusParams): Promise<void>;
+
   // dataloader
   getBlocksByEventIds(eventIds: string[]): Promise<BlockOutput[]>;
   getBlocksByTransactionIds(transactionIds: string[]): Promise<BlockOutput[]>;

indexer/src/kadena-server/repository/infra/repository/block-db-repository.ts

@@ -14,15 +14,16 @@
  * - Optimized batch retrieval through DataLoader patterns
  */
 
-import { FindOptions, Op, QueryTypes } from 'sequelize';
+import { Op, QueryTypes } from 'sequelize';
 import { rootPgPool, sequelize } from '../../../../config/database';
-import BlockModel, { BlockAttributes } from '../../../../models/block';
+import BlockModel from '../../../../models/block';
 import BlockRepository, {
   BlockOutput,
   GetBlocksBetweenHeightsParams,
   GetBlocksFromDepthParams,
   GetCompletedBlocksParams,
   GetLatestBlocksParams,
+  UpdateCanonicalStatusParams,
 } from '../../application/block-repository';
 import { getPageInfo, getPaginationParams } from '../../pagination';
 import { blockValidator } from '../schema-validator/block-schema-validator';
@@ -53,14 +54,12 @@ export default class BlockDbRepository implements BlockRepository {
    * @returns Promise resolving to the block data if found
    * @throws Error if the block is not found
    */
-  async getBlockByHash(hash: string) {
+  async getBlockByHash(hash: string): Promise<BlockOutput | null> {
     const block = await BlockModel.findOne({
       where: { hash },
     });
 
-    if (!block) {
-      throw new Error('Block not found.');
-    }
+    if (!block) return null;
 
     return blockValidator.mapFromSequelize(block);
   }
@@ -314,7 +313,8 @@ export default class BlockDbRepository implements BlockRepository {
         b.target as "target",
         b.coinbase as "coinbase",
         b.adjacents as "adjacents",
-        b.parent as "parent"
+        b.parent as "parent",
+        b.canonical as "canonical"
       FROM "Blocks" b
       WHERE b.height >= $2
       ${conditions}
@@ -594,6 +594,7 @@ export default class BlockDbRepository implements BlockRepository {
         b.coinbase as "coinbase",
         b.adjacents as "adjacents",
         b.parent as "parent",
+        b.canonical as "canonical",
         t.id as "transactionId"
         FROM "Blocks" b
         JOIN "Transactions" t ON b.id = t."blockId"
@@ -641,7 +642,8 @@ export default class BlockDbRepository implements BlockRepository {
         b.target as "target",
         b.coinbase as "coinbase",
         b.adjacents as "adjacents",
-        b.parent as "parent"
+        b.parent as "parent",
+        b.canonical as "canonical"
         FROM "Blocks" b
         WHERE b.hash = ANY($1::text[])`,
       [hashes],
@@ -923,4 +925,84 @@ export default class BlockDbRepository implements BlockRepository {
 
     return Object.assign({}, ...maxHeightsArray);
   }
+
+  async getBlocksWithSameHeight(height: number, chainId: string): Promise<BlockOutput[]> {
+    const query = `
+      SELECT b.*
+      FROM "Blocks" b
+      WHERE b."height" = $1 AND b."chainId" = $2
+    `;
+
+    const { rows } = await rootPgPool.query(query, [height, chainId]);
+
+    return rows.map(row => blockValidator.validate(row));
+  }
+
+  async getBlockNParent(depth: number, hash: string): Promise<string | undefined> {
+    const query = `
+      WITH RECURSIVE BlockAncestors AS (
+        SELECT hash, parent, 1 AS depth, height
+        FROM "Blocks"
+        WHERE hash = $1
+        UNION ALL
+        SELECT b.hash, b.parent, d.depth + 1 AS depth, b.height
+        FROM BlockAncestors d
+        JOIN "Blocks" b ON d.parent = b.hash
+        WHERE d.depth < $2
+      )
+      SELECT parent as hash, depth
+      FROM BlockAncestors
+      ORDER BY depth DESC
+      LIMIT 1;
+    `;
+    const { rows } = await rootPgPool.query(query, [hash, depth]);
+
+    return rows?.[0]?.hash;
+  }
+
+  async getBlocksWithHeightHigherThan(height: number, chainId: string): Promise<BlockOutput[]> {
+    const query = `
+      SELECT b.*
+      FROM "Blocks" b
+      WHERE b.height > $1 AND b."chainId" = $2;
+    `;
+
+    const { rows } = await rootPgPool.query(query, [height, chainId]);
+
+    return rows.map(row => blockValidator.validate(row));
+  }
+
+  async updateCanonicalStatus(params: UpdateCanonicalStatusParams) {
+    const canonicalHashes = params.blocks
+      .filter(change => change.canonical)
+      .map(change => change.hash);
+    const nonCanonicalHashes = params.blocks
+      .filter(change => !change.canonical)
+      .map(change => change.hash);
+
+    await rootPgPool.query('BEGIN');
+    try {
+      if (canonicalHashes.length > 0) {
+        const canonicalQuery = `
+          UPDATE "Blocks"
+          SET "canonical" = true
+          WHERE hash = ANY($1)
+        `;
+        await rootPgPool.query(canonicalQuery, [canonicalHashes]);
+      }
+
+      if (nonCanonicalHashes.length > 0) {
+        const nonCanonicalQuery = `
+          UPDATE "Blocks"
+          SET "canonical" = false
+          WHERE hash = ANY($1)
+        `;
+        await rootPgPool.query(nonCanonicalQuery, [nonCanonicalHashes]);
+      }
+      await rootPgPool.query('COMMIT');
+    } catch (error) {
+      await rootPgPool.query('ROLLBACK');
+      throw error;
+    }
+  }
 }

indexer/src/kadena-server/repository/infra/schema-validator/block-schema-validator.ts

@@ -41,6 +41,7 @@ const schema = zod.object({
   adjacents: zod.record(zod.any()),
   parent: zod.string(),
   coinbase: zod.any(),
+  canonical: zod.boolean().nullable(),
 });
 
 /**
@@ -75,13 +76,15 @@ const getBase64ID = (hash: string): string => {
  */
 const validate = (row: any): BlockOutput => {
   const res = schema.parse(row);
+  const isCanonicalNull = res.canonical === null;
+  const canonicalValue = res.canonical ?? false;
   return {
     id: getBase64ID(res.hash),
     parentHash: res.parent,
     creationTime: convertStringToDate(res.creationTime),
     epoch: convertStringToDate(res.epochStart),
     flags: int64ToUint64String(res.featureFlags),
-    powHash: '...', // TODO (STREAMING)
+    powHash: '',
     hash: res.hash,
     height: res.height,
     nonce: res.nonce,
@@ -90,6 +93,7 @@ const validate = (row: any): BlockOutput => {
     coinbase: JSON.stringify(res.coinbase),
     weight: res.weight,
     chainId: res.chainId,
+    canonical: isCanonicalNull ? true : canonicalValue,
     difficulty: Number(calculateBlockDifficulty(res.target)),
     neighbors: Object.entries(res.adjacents).map(([chainId, hash]) => ({
       chainId,
@@ -110,13 +114,16 @@ const validate = (row: any): BlockOutput => {
  * @returns A transformed BlockOutput object
  */
 const mapFromSequelize = (blockModel: BlockAttributes): BlockOutput => {
+  const isCanonicalNull = blockModel.canonical === null;
+  const canonicalValue = blockModel.canonical ?? false;
   return {
     id: getBase64ID(blockModel.hash),
     hash: blockModel.hash,
     parentHash: blockModel.parent,
     chainId: blockModel.chainId,
+    canonical: isCanonicalNull ? true : canonicalValue,
     creationTime: convertStringToDate(blockModel.creationTime),
-    powHash: '...', // TODO (STREAMING)
+    powHash: '',
     difficulty: Number(calculateBlockDifficulty(blockModel.target)),
     epoch: convertStringToDate(blockModel.epochStart),
     flags: int64ToUint64String(blockModel.featureFlags),

indexer/src/kadena-server/resolvers/fields/transfer/block-transfer-resolver.ts

@@ -32,5 +32,9 @@ export const blockTransferResolver: TransferResolvers<ResolverContext>['block']
   const { blockHash } = schema.parse(parent);
   const output = await context.blockRepository.getBlockByHash(blockHash);
 
+  if (!output) {
+    throw new Error('[ERROR][DB][DATA_MISSING] Block transfer not found.');
+  }
+
   return buildBlockOutput(output);
 };

indexer/src/kadena-server/resolvers/index.ts

@@ -263,7 +263,7 @@ export const resolvers: Resolvers<ResolverContext> = {
      * @returns The GraphQL type name as a string, or null if unrecognized
      */
     __resolveType(obj: any) {
-      if (obj.difficulty && obj.powHash) {
+      if (obj.difficulty && obj.hash) {
         return 'Block';
       }
 

indexer/src/kadena-server/resolvers/node-utils.ts

@@ -59,6 +59,9 @@ export const getNode = async (context: ResolverContext, id: string) => {
   if (type === 'Block') {
     // Resolve Block node - only requires the block hash as a parameter
     const output = await context.blockRepository.getBlockByHash(params);
+    if (!output) {
+      throw new Error('[ERROR][DB][DATA_MISSING] Block not found.');
+    }
     return buildBlockOutput(output);
   }
 

indexer/src/kadena-server/resolvers/query/block-query-resolver.ts

@@ -33,5 +33,9 @@ export const blockQueryResolver: QueryResolvers<ResolverContext>['block'] = asyn
   const { hash } = args;
   const output = await context.blockRepository.getBlockByHash(hash);
 
+  if (!output) {
+    throw new Error('[ERROR][DB][DATA_MISSING] Block not found.');
+  }
+
   return buildBlockOutput(output);
 };