Chang

Author: Sluder

package-lock.json

@@ -26,7 +26,7 @@
     "@babel/core": "^7.24.5",
     "@babel/preset-env": "^7.24.5",
     "@babel/preset-typescript": "^7.24.1",
-    "@cardano-ogmios/client": "^5.5.7",
+    "@cardano-ogmios/client": "^6.6.0",
     "@types/cors": "^2.8.14",
     "@types/express": "^4.17.17",
     "@types/helmet": "^4.0.0",

package.json

@@ -1,14 +1,13 @@
 import 'reflect-metadata';
 import { dbService, eventService, metadataService, operationWs, queue } from './indexerServices';
 import {
-    createChainSyncClient,
+    createChainSynchronizationClient,
     createInteractionContext,
     InteractionContext
 } from '@cardano-ogmios/client';
-import { Block, TipOrOrigin, Point, PointOrOrigin, BlockAlonzo, BlockBabbage } from '@cardano-ogmios/schema';
+import { Block, TipOrOrigin, Point, PointOrOrigin, BlockPraos } from '@cardano-ogmios/schema';
 import { logError, logInfo } from './logger';
 import { BaseIndexer } from './indexers/BaseIndexer';
-import { ChainSyncClient } from '@cardano-ogmios/client/dist/ChainSync';
 import { AmmDexTransactionIndexer } from './indexers/AmmDexTransactionIndexer';
 import { BaseCacheStorage } from './storage/BaseCacheStorage';
 import { MinswapAnalyzer } from './dex/MinswapAnalyzer';
@@ -29,14 +28,15 @@ import { CacheStorage } from './storage/CacheStorage';
 import { HybridDexTransactionIndexer } from './indexers/HybridDexTransactionIndexer';
 import { AxoAnalyzer } from './dex/AxoAnalyzer';
 import { VyFiAnalyzer } from './dex/VyFiAnalyzer';
+import { ChainSynchronization } from '@cardano-ogmios/client';
 // import { SundaeSwapV3Analyzer } from './dex/SundaeSwapV3Analyzer';
 
 export class IndexerApplication {
 
     private readonly _cache: BaseCacheStorage;
 
     private _eventListeners: BaseEventListener[] = [];
-    private chainSyncClient: ChainSyncClient | undefined = undefined;
+    private chainSyncClient: ChainSynchronization.ChainSynchronizationClient | undefined = undefined;
 
     /**
      * Indexers to make aware of new blocks & rollbacks.
@@ -150,7 +150,7 @@ export class IndexerApplication {
             process.exit(0);
         });
 
-        this.chainSyncClient = await createChainSyncClient(
+        this.chainSyncClient = await createChainSynchronizationClient(
             context,
             {
                 rollForward: this.rollForward.bind(this),
@@ -178,8 +178,8 @@ export class IndexerApplication {
          * GeniusYield - 110315300, d7281a52d68eef89a7472860fdece323ecc39d3054cdd1fa0825afe56b942a86
          */
         return lastSync
-            ? this.chainSyncClient.startSync([{ slot: lastSync.slot, hash: lastSync.blockHash }])
-            : this.chainSyncClient.startSync([{ slot: FIRST_SYNC_SLOT, hash: FIRST_SYNC_BLOCK_HASH }]);
+            ? this.chainSyncClient?.resume([{ slot: lastSync.slot, id: lastSync.blockHash }])
+            : this.chainSyncClient?.resume([{ slot: FIRST_SYNC_SLOT, id: FIRST_SYNC_BLOCK_HASH }]);
     }
 
     /**
@@ -188,19 +188,13 @@ export class IndexerApplication {
      * @param requestNext - Callback to request next block.
      */
     private async rollForward(update: { block: Block, tip: TipOrOrigin }, requestNext: () => void): Promise<void> {
-        let block: BlockAlonzo | BlockBabbage | undefined = undefined;
+        if (update.block.type === 'praos') {
+            const block: BlockPraos = update.block;
 
-        if ('babbage' in update.block) {
-            block = update.block.babbage;
-        } else if ('alonzo' in update.block) {
-            block = update.block.alonzo;
-        }
-
-        if (block) {
-            logInfo(`====== Analyzing block at slot ${block.header.slot} ======`);
+            logInfo(`====== Analyzing block at slot ${block.slot} ======`);
 
             await Promise.all(
-                this._indexers.map((indexer: BaseIndexer) => indexer.onRollForward(block as BlockAlonzo | BlockBabbage)),
+                this._indexers.map((indexer: BaseIndexer) => indexer.onRollForward(block)),
             );
 
             if (queue.size > 0) {
@@ -209,7 +203,7 @@ export class IndexerApplication {
                 logInfo('[Queue] Finished jobs');
             }
 
-            logInfo(`====== Finished with block at slot ${block.header.slot} ======`);
+            logInfo(`====== Finished with block at slot ${block.slot} ======`);
         }
 
         requestNext();
@@ -227,7 +221,7 @@ export class IndexerApplication {
             const point: Point = update.point;
 
             await Promise.all(
-                this._indexers.map((indexer: BaseIndexer) => indexer.onRollBackward(point.hash, point.slot)),
+                this._indexers.map((indexer: BaseIndexer) => indexer.onRollBackward(point.id, point.slot)),
             );
         }
 

src/IndexerApplication.ts

@@ -11,6 +11,7 @@ import { LiquidityPoolDeposit } from '../db/entities/LiquidityPoolDeposit';
 import { LiquidityPoolZap } from '../db/entities/LiquidityPoolZap';
 import { LiquidityPoolWithdraw } from '../db/entities/LiquidityPoolWithdraw';
 import { IndexerApplication } from '../IndexerApplication';
+import { Redeemer } from '@cardano-ogmios/schema';
 
 export abstract class BaseAmmDexAnalyzer {
 
@@ -56,11 +57,9 @@ export abstract class BaseAmmDexAnalyzer {
      * Retrieve the corresponding spent operations for a transaction.
      */
     protected spentOperationInputs(transaction: Transaction): OperationStatus[] {
-        const indexes: number[] = Object.keys(transaction.redeemers).filter((label: string) => {
-            return label.startsWith('spend');
-        }).map((label: string) => {
-            return parseInt(label.split(':')[1]);
-        });
+        const indexes: number[] = transaction.redeemers.filter((redeemer: Redeemer) => {
+            return redeemer.validator.purpose === 'spend';
+        }).map((redeemer: Redeemer) => redeemer.validator.index);
 
         return transaction.inputs.reduce((spentInputs: OperationStatus[], input: Utxo, index: number) => {
             if (indexes.includes(index)) {
@@ -87,15 +86,17 @@ export abstract class BaseAmmDexAnalyzer {
      */
     protected cancelledOperationInputs(transaction: Transaction, orderAddresses: string[], redeemerDatum: string): OperationStatus[] {
         const containsOrderAddress: boolean = transaction.scriptHashes?.some((scriptHash: string) => {
-           return orderAddresses.includes(scriptHashToAddress(scriptHash));
+            return orderAddresses.includes(scriptHashToAddress(scriptHash));
         }) ?? false;
 
         if (! containsOrderAddress) return [];
 
         return transaction.inputs.reduce((cancelInputs: OperationStatus[], input: Utxo, index: number) => {
-            const redeemerLabel: string = `spend:${index}`;
+            const redeemer: Redeemer | undefined = transaction.redeemers.find((redeemer: Redeemer) => {
+                return redeemer.validator.index === index && redeemer.redeemer === redeemerDatum;
+            });
 
-            if ((redeemerLabel in transaction.redeemers) && transaction.redeemers[redeemerLabel] === redeemerDatum) {
+            if (redeemer) {
                 cancelInputs.push(
                     OperationStatus.make(
                         DexOperationStatus.Cancelled,

src/dex/BaseAmmDexAnalyzer.ts

@@ -1,4 +1,4 @@
-import { AmmDexOperation, HybridOperation, OrderBookDexOperation, Transaction, Utxo } from '../types';
+import { HybridOperation, Transaction, Utxo } from '../types';
 import { scriptHashToAddress } from '../utils';
 import { DexOperationStatus } from '../constants';
 import { OperationStatus } from '../db/entities/OperationStatus';
@@ -10,6 +10,7 @@ import { LiquidityPoolWithdraw } from '../db/entities/LiquidityPoolWithdraw';
 import { IndexerApplication } from '../IndexerApplication';
 import { OrderBookMatch } from '../db/entities/OrderBookMatch';
 import { OrderBookOrder } from '../db/entities/OrderBookOrder';
+import { Redeemer } from '@cardano-ogmios/schema';
 
 export abstract class BaseHybridDexAnalyzer {
 
@@ -41,11 +42,9 @@ export abstract class BaseHybridDexAnalyzer {
      * Retrieve the corresponding spent operations for a transaction.
      */
     protected spentOperationInputs(transaction: Transaction): OperationStatus[] {
-        const indexes: number[] = Object.keys(transaction.redeemers).filter((label: string) => {
-            return label.startsWith('spend');
-        }).map((label: string) => {
-            return parseInt(label.split(':')[1]);
-        });
+        const indexes: number[] = transaction.redeemers.filter((redeemer: Redeemer) => {
+            return redeemer.validator.purpose === 'spend';
+        }).map((redeemer: Redeemer) => redeemer.validator.index);
 
         return transaction.inputs.reduce((spentInputs: OperationStatus[], input: Utxo, index: number) => {
             if (indexes.includes(index)) {
@@ -78,9 +77,11 @@ export abstract class BaseHybridDexAnalyzer {
         if (! containsOrderAddress) return [];
 
         return transaction.inputs.reduce((cancelInputs: OperationStatus[], input: Utxo, index: number) => {
-            const redeemerLabel: string = `spend:${index}`;
+            const redeemer: Redeemer | undefined = transaction.redeemers.find((redeemer: Redeemer) => {
+               return redeemer.validator.index === index && redeemer.redeemer === redeemerDatum;
+            });
 
-            if ((redeemerLabel in transaction.redeemers) && transaction.redeemers[redeemerLabel] === redeemerDatum) {
+            if (redeemer) {
                 cancelInputs.push(
                     OperationStatus.make(
                         DexOperationStatus.Cancelled,

src/dex/BaseHybridDexAnalyzer.ts

@@ -1,5 +1,5 @@
 import { BaseIndexer } from './BaseIndexer';
-import { BlockAlonzo, BlockBabbage, Slot, TxAlonzo, TxBabbage } from '@cardano-ogmios/schema';
+import { Slot, BlockPraos, Transaction as OgmiosTransaction } from '@cardano-ogmios/schema';
 import { BaseAmmDexAnalyzer } from '../dex/BaseAmmDexAnalyzer';
 import { AmmDexOperation, Transaction } from '../types';
 import { dbService } from '../indexerServices';
@@ -21,8 +21,8 @@ export class AmmDexTransactionIndexer extends BaseIndexer {
         this._handler = new AmmOperationHandler();
     }
 
-    async onRollForward(block: BlockBabbage | BlockAlonzo): Promise<any> {
-        const operationPromises: Promise<AmmDexOperation[]>[] = block.body?.map((transaction: TxBabbage | TxAlonzo) => {
+    async onRollForward(block: BlockPraos): Promise<any> {
+        const operationPromises: Promise<AmmDexOperation[]>[] = (block.transactions ?? []).map((transaction: OgmiosTransaction) => {
             return this._analyzers.map((analyzer: BaseAmmDexAnalyzer) => {
                 const tx: Transaction = formatTransaction(block, transaction);
 

src/indexers/AmmDexTransactionIndexer.ts

@@ -1,8 +1,8 @@
-import { BlockAlonzo, BlockBabbage, Slot } from '@cardano-ogmios/schema';
+import { BlockPraos, Slot } from '@cardano-ogmios/schema';
 
 export abstract class BaseIndexer {
 
-    abstract onRollForward(block: BlockBabbage | BlockAlonzo): Promise<any>;
+    abstract onRollForward(block: BlockPraos): Promise<any>;
 
     abstract onRollBackward(blockHash: string, slot: Slot): Promise<any>;
 

src/indexers/BaseIndexer.ts

@@ -1,5 +1,5 @@
 import { BaseIndexer } from './BaseIndexer';
-import { BlockAlonzo, BlockBabbage, Slot, TxAlonzo, TxBabbage } from '@cardano-ogmios/schema';
+import { Slot, BlockPraos, Transaction as OgmiosTransaction } from '@cardano-ogmios/schema';
 import { HybridOperation, Transaction } from '../types';
 import { LiquidityPoolState } from '../db/entities/LiquidityPoolState';
 import { OperationStatus } from '../db/entities/OperationStatus';
@@ -21,8 +21,8 @@ export class HybridDexTransactionIndexer extends BaseIndexer {
         this._handler = new HybridOperationHandler();
     }
 
-    async onRollForward(block: BlockBabbage | BlockAlonzo): Promise<any> {
-        const operationPromises: Promise<HybridOperation[]>[] = block.body?.map((transaction: TxBabbage | TxAlonzo) => {
+    async onRollForward(block: BlockPraos): Promise<any> {
+        const operationPromises: Promise<HybridOperation[]>[] = (block.transactions ?? []).map((transaction: OgmiosTransaction) => {
             return this._analyzers.map((analyzer: BaseHybridDexAnalyzer) => {
                 const tx: Transaction = formatTransaction(block, transaction);
 

src/indexers/HybridDexTransactionIndexer.ts

@@ -1,5 +1,5 @@
 import { BaseIndexer } from './BaseIndexer';
-import { BlockAlonzo, BlockBabbage, Slot, TxAlonzo, TxBabbage } from '@cardano-ogmios/schema';
+import { Slot, BlockPraos, Transaction as OgmiosTransaction } from '@cardano-ogmios/schema';
 import { OrderBookDexOperation, Transaction } from '../types';
 import { dbService } from '../indexerServices';
 import { EntityManager, MoreThan } from 'typeorm';
@@ -23,8 +23,8 @@ export class OrderBookDexTransactionIndexer extends BaseIndexer {
         this._handler = new OrderBookOperationHandler();
     }
 
-    async onRollForward(block: BlockBabbage | BlockAlonzo): Promise<any> {
-        const operationPromises: Promise<OrderBookDexOperation[]>[] = block.body?.map((transaction: TxBabbage | TxAlonzo) => {
+    async onRollForward(block: BlockPraos): Promise<any> {
+        const operationPromises: Promise<OrderBookDexOperation[]>[] = (block.transactions ?? []).map((transaction: OgmiosTransaction) => {
             return this._analyzers.map((analyzer: BaseOrderBookDexAnalyzer) => {
                 const tx: Transaction = formatTransaction(block, transaction);