@my-packages-changeit/cardano-scanner 2.2.0

package/dist/scanner/ogmios.d.ts

@@ -0,0 +1,51 @@
+import { ChainSynchronizationClient } from '@cardano-ogmios/client/dist/ChainSynchronization';
+import { Point, Transaction } from '@cardano-ogmios/schema';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { WebSocketScanner } from '@rosen-bridge/abstract-scanner';
+import { CardanoOgmiosConfig } from '../interfaces';
+declare class CardanoOgmiosScanner extends WebSocketScanner<Transaction> {
+    client: ChainSynchronizationClient;
+    initPoint: Point;
+    host: string;
+    port: number;
+    useTls: boolean;
+    private connected;
+    private stopped;
+    private reconnectionConfig;
+    constructor(config: CardanoOgmiosConfig, logger?: AbstractLogger);
+    /**
+     * process block when a block forked library call this function
+     * @param response: forked block
+     * @param requestNext: a function to tell node to send next block
+     */
+    private rollBackward;
+    /**
+     * Step forward when new block arrived ogmios-client call this function
+     * @param response: new block
+     * @param requestNext: tell library that this block proceeds. pass next block when available
+     */
+    private rollForward;
+    /**
+     * find intersect between stored blocks and blockchain.
+     * @param context: blockchain context
+     */
+    private findIntersection;
+    /**
+     * Handles ogmios connection closure
+     */
+    private connectionCloseHandler;
+    /**
+     * start scanner. first find fork point. fork all blocks and request updates from node.
+     */
+    start: () => Promise<void>;
+    /**
+     * stop ws connection to node.
+     */
+    stop: () => Promise<void>;
+    /**
+     * @returns The connection status of ogmios scanner
+     */
+    getConnectionStatus: () => boolean;
+}
+export { CardanoOgmiosScanner };
+//# sourceMappingURL=ogmios.d.ts.map

package/dist/scanner/ogmios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogmios.d.ts","sourceRoot":"","sources":["../../lib/scanner/ogmios.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,0BAA0B,EAE3B,MAAM,kDAAkD,CAAC;AAC1D,OAAO,EAGL,KAAK,EAGL,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAEL,gBAAgB,EACjB,MAAM,gCAAgC,CAAC;AAQxC,OAAO,EAAE,mBAAmB,EAA4B,MAAM,eAAe,CAAC;AAY9E,cAAM,oBAAqB,SAAQ,gBAAgB,CAAC,WAAW,CAAC;IAC9D,MAAM,EAAE,0BAA0B,CAAC;IACnC,SAAS,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,kBAAkB,CAA2B;gBAEzC,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,cAAc;IAoBhE;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAsBlB;IAEF;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAuBjB;IAEF;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAkCtB;IAEF;;OAEG;IACH,OAAO,CAAC,sBAAsB,CA6B5B;IAEF;;OAEG;IACH,KAAK,QAAa,OAAO,CAAC,IAAI,CAAC,CAwB7B;IAEF;;OAEG;IACH,IAAI,QAAa,OAAO,CAAC,IAAI,CAAC,CAG5B;IAEF;;OAEG;IACH,mBAAmB,gBAAwB;CAC5C;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/scanner/ogmios.js

@@ -0,0 +1,173 @@
+import { createChainSynchronizationClient, } from '@cardano-ogmios/client';
+import { createInteractionContext } from '@cardano-ogmios/client';
+import { findIntersection, } from '@cardano-ogmios/client/dist/ChainSynchronization';
+import { ExponentialBackoff, handleWhen, retry } from 'cockatiel';
+import { BlockDbAction, WebSocketScanner, } from '@rosen-bridge/abstract-scanner';
+import { RECONNECTION_INITIAL_DELAY, RECONNECTION_MAX_DELAY, SLOT_SHELLY_NUMBER, RECONNECTION_MAX_ATTEMPTS, } from '../constants';
+class CardanoOgmiosScanner extends WebSocketScanner {
+    client;
+    initPoint;
+    host;
+    port;
+    useTls;
+    connected;
+    stopped;
+    reconnectionConfig;
+    constructor(config, logger) {
+        super('cardano', logger, config.maxTryBlock, config.suffix);
+        this.action = new BlockDbAction(config.dataSource, this.name(), logger);
+        this.host = config.nodeHostOrIp;
+        this.port = config.nodePort;
+        this.useTls = config.useTls ?? false;
+        this.connected = false;
+        this.initPoint = {
+            id: config.initialHash,
+            slot: config.initialSlot,
+        };
+        this.reconnectionConfig = {
+            initialDelay: config.reconnectionConfig?.initialDelay ?? RECONNECTION_INITIAL_DELAY,
+            maxDelay: config.reconnectionConfig?.maxDelay ?? RECONNECTION_MAX_DELAY,
+            maxAttempts: config.reconnectionConfig?.maxAttempts ?? RECONNECTION_MAX_ATTEMPTS,
+        };
+    }
+    /**
+     * process block when a block forked library call this function
+     * @param response: forked block
+     * @param requestNext: a function to tell node to send next block
+     */
+    rollBackward = async (response, requestNext) => {
+        const hash = response.point.id;
+        const savedBlock = await this.action.getBlockWithHash(hash);
+        this.logger.debug(`Rolling backward to height ${savedBlock?.height} in scanner ${this.name()}`);
+        if (savedBlock) {
+            const block = {
+                hash: savedBlock.hash,
+                height: savedBlock.height,
+                parentHash: savedBlock.parentHash,
+                extra: savedBlock.extra,
+                timestamp: savedBlock.timestamp,
+            };
+            await this.stepBackward(block);
+        }
+        requestNext();
+    };
+    /**
+     * Step forward when new block arrived ogmios-client call this function
+     * @param response: new block
+     * @param requestNext: tell library that this block proceeds. pass next block when available
+     */
+    rollForward = async (response, requestNext) => {
+        if (response.block.type === 'praos') {
+            const praosBlock = response.block;
+            this.logger.debug(`Queueing new block at height ${praosBlock.height} in scanner ${this.name()}`);
+            const block = {
+                hash: praosBlock.id,
+                height: praosBlock.height,
+                parentHash: praosBlock.ancestor,
+                extra: `${praosBlock.slot}`,
+                // Caution: In case of a hard fork and change in slot duration, this must change!
+                timestamp: praosBlock.slot + SLOT_SHELLY_NUMBER,
+            };
+            if (praosBlock.transactions)
+                await this.stepForward(block, praosBlock.transactions);
+        }
+        requestNext();
+    };
+    /**
+     * find intersect between stored blocks and blockchain.
+     * @param context: blockchain context
+     */
+    findIntersection = async (context) => {
+        let count = 1;
+        let skip = 0;
+        while (count !== 0) {
+            try {
+                const release = await this.mutex.acquire();
+                const blocks = await this.action.getLastSavedBlocks(skip, count);
+                release();
+                if (blocks.length === 0)
+                    count = 0;
+                const points = blocks.length > 0
+                    ? blocks.map((item) => ({
+                        slot: item.extra ? parseInt(item.extra) : 0,
+                        id: item.hash,
+                    }))
+                    : [this.initPoint];
+                const intersect = await findIntersection(context, points);
+                const intersectPoint = intersect.intersection;
+                let height = 0;
+                if (blocks.length) {
+                    const foundedBlock = blocks.find((item) => (item.hash = intersectPoint.id));
+                    if (foundedBlock) {
+                        height = foundedBlock.height;
+                    }
+                }
+                return { point: intersect.intersection, height: height };
+            }
+            catch {
+                skip += count;
+                count *= 2;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Handles ogmios connection closure
+     */
+    connectionCloseHandler = async () => {
+        this.connected = false;
+        this.logger.warn('Ogmios connection closed');
+        if (this.stopped)
+            return;
+        const retryPolicy = retry(handleWhen((error) => {
+            this.logger.warn(`An error occurred while reconnecting to ogmios client: ${error}`);
+            return true;
+        }), {
+            maxAttempts: this.reconnectionConfig.maxAttempts,
+            backoff: new ExponentialBackoff({
+                maxDelay: this.reconnectionConfig.maxDelay,
+                initialDelay: this.reconnectionConfig.initialDelay,
+            }),
+        });
+        let trial = 0;
+        retryPolicy.execute(async () => {
+            trial++;
+            this.logger.debug(`Retrying to connect to ogmios client in trial step #${trial}`);
+            return await this.start();
+        });
+    };
+    /**
+     * start scanner. first find fork point. fork all blocks and request updates from node.
+     */
+    start = async () => {
+        this.stopped = false;
+        const context = await createInteractionContext((err) => this.logger.error(`${err}`), this.connectionCloseHandler, { connection: { port: this.port, host: this.host, tls: this.useTls } });
+        const intersect = await this.findIntersection(context);
+        if (intersect) {
+            // find intersect then start from that point
+            this.client = await createChainSynchronizationClient(context, {
+                rollBackward: this.rollBackward,
+                rollForward: this.rollForward,
+            }, { sequential: true });
+            this.connected = true;
+            await this.forkBlock(intersect.height + 1);
+            await this.client.resume([intersect.point], 2);
+        }
+        else {
+            throw Error('Can not start scanner. initial block is invalid');
+        }
+    };
+    /**
+     * stop ws connection to node.
+     */
+    stop = async () => {
+        this.stopped = true;
+        await this.client.shutdown();
+    };
+    /**
+     * @returns The connection status of ogmios scanner
+     */
+    getConnectionStatus = () => this.connected;
+}
+export { CardanoOgmiosScanner };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ogmios.js","sourceRoot":"","sources":["../../lib/scanner/ogmios.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createChainSynchronizationClient,\n  InteractionContext,\n} from '@cardano-ogmios/client';\nimport { createInteractionContext } from '@cardano-ogmios/client';\nimport {\n  ChainSynchronizationClient,\n  findIntersection,\n} from '@cardano-ogmios/client/dist/ChainSynchronization';\nimport {\n  Block,\n  BlockPraos,\n  Point,\n  PointOrOrigin,\n  TipOrOrigin,\n  Transaction,\n} from '@cardano-ogmios/schema';\nimport { ExponentialBackoff, handleWhen, retry } from 'cockatiel';\n\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  BlockDbAction,\n  WebSocketScanner,\n} from '@rosen-bridge/abstract-scanner';\n\nimport {\n  RECONNECTION_INITIAL_DELAY,\n  RECONNECTION_MAX_DELAY,\n  SLOT_SHELLY_NUMBER,\n  RECONNECTION_MAX_ATTEMPTS,\n} from '../constants';\nimport { CardanoOgmiosConfig, OgmiosReconnectionConfig } from '../interfaces';\n\ninterface BackwardResponse {\n  point: PointOrOrigin;\n  tip: TipOrOrigin;\n}\n\ninterface ForwardResponse {\n  block: Block;\n  tip: TipOrOrigin;\n}\n\nclass CardanoOgmiosScanner extends WebSocketScanner<Transaction> {\n  client: ChainSynchronizationClient;\n  initPoint: Point;\n  host: string;\n  port: number;\n  useTls: boolean;\n  private connected: boolean;\n  private stopped: boolean;\n  private reconnectionConfig: OgmiosReconnectionConfig;\n\n  constructor(config: CardanoOgmiosConfig, logger?: AbstractLogger) {\n    super('cardano', logger, config.maxTryBlock, config.suffix);\n    this.action = new BlockDbAction(config.dataSource, this.name(), logger);\n    this.host = config.nodeHostOrIp;\n    this.port = config.nodePort;\n    this.useTls = config.useTls ?? false;\n    this.connected = false;\n    this.initPoint = {\n      id: config.initialHash,\n      slot: config.initialSlot,\n    };\n    this.reconnectionConfig = {\n      initialDelay:\n        config.reconnectionConfig?.initialDelay ?? RECONNECTION_INITIAL_DELAY,\n      maxDelay: config.reconnectionConfig?.maxDelay ?? RECONNECTION_MAX_DELAY,\n      maxAttempts:\n        config.reconnectionConfig?.maxAttempts ?? RECONNECTION_MAX_ATTEMPTS,\n    };\n  }\n\n  /**\n   * process block when a block forked library call this function\n   * @param response: forked block\n   * @param requestNext: a function to tell node to send next block\n   */\n  private rollBackward = async (\n    response: BackwardResponse,\n    requestNext: () => void,\n  ) => {\n    const hash = (response.point as Point).id;\n    const savedBlock = await this.action.getBlockWithHash(hash);\n    this.logger.debug(\n      `Rolling backward to height ${\n        savedBlock?.height\n      } in scanner ${this.name()}`,\n    );\n    if (savedBlock) {\n      const block = {\n        hash: savedBlock.hash,\n        height: savedBlock.height,\n        parentHash: savedBlock.parentHash,\n        extra: savedBlock.extra,\n        timestamp: savedBlock.timestamp,\n      };\n      await this.stepBackward(block);\n    }\n    requestNext();\n  };\n\n  /**\n   * Step forward when new block arrived ogmios-client call this function\n   * @param response: new block\n   * @param requestNext: tell library that this block proceeds. pass next block when available\n   */\n  private rollForward = async (\n    response: ForwardResponse,\n    requestNext: () => void,\n  ) => {\n    if (response.block.type === 'praos') {\n      const praosBlock = response.block as BlockPraos;\n      this.logger.debug(\n        `Queueing new block at height ${\n          praosBlock.height\n        } in scanner ${this.name()}`,\n      );\n      const block = {\n        hash: praosBlock.id,\n        height: praosBlock.height,\n        parentHash: praosBlock.ancestor,\n        extra: `${praosBlock.slot}`,\n        // Caution: In case of a hard fork and change in slot duration, this must change!\n        timestamp: praosBlock.slot + SLOT_SHELLY_NUMBER,\n      };\n      if (praosBlock.transactions)\n        await this.stepForward(block, praosBlock.transactions);\n    }\n    requestNext();\n  };\n\n  /**\n   * find intersect between stored blocks and blockchain.\n   * @param context: blockchain context\n   */\n  private findIntersection = async (context: InteractionContext) => {\n    let count = 1;\n    let skip = 0;\n    while (count !== 0) {\n      try {\n        const release = await this.mutex.acquire();\n        const blocks = await this.action.getLastSavedBlocks(skip, count);\n        release();\n        if (blocks.length === 0) count = 0;\n        const points =\n          blocks.length > 0\n            ? blocks.map((item) => ({\n                slot: item.extra ? parseInt(item.extra) : 0,\n                id: item.hash,\n              }))\n            : [this.initPoint];\n        const intersect = await findIntersection(context, points);\n        const intersectPoint = intersect.intersection as Point;\n        let height = 0;\n        if (blocks.length) {\n          const foundedBlock = blocks.find(\n            (item) => (item.hash = intersectPoint.id),\n          );\n          if (foundedBlock) {\n            height = foundedBlock.height;\n          }\n        }\n        return { point: intersect.intersection as Point, height: height };\n      } catch {\n        skip += count;\n        count *= 2;\n      }\n    }\n    return undefined;\n  };\n\n  /**\n   * Handles ogmios connection closure\n   */\n  private connectionCloseHandler = async () => {\n    this.connected = false;\n    this.logger.warn('Ogmios connection closed');\n    if (this.stopped) return;\n\n    const retryPolicy = retry(\n      handleWhen((error: Error) => {\n        this.logger.warn(\n          `An error occurred while reconnecting to ogmios client: ${error}`,\n        );\n        return true;\n      }),\n      {\n        maxAttempts: this.reconnectionConfig.maxAttempts,\n        backoff: new ExponentialBackoff({\n          maxDelay: this.reconnectionConfig.maxDelay,\n          initialDelay: this.reconnectionConfig.initialDelay,\n        }),\n      },\n    );\n\n    let trial = 0;\n    retryPolicy.execute(async () => {\n      trial++;\n      this.logger.debug(\n        `Retrying to connect to ogmios client in trial step #${trial}`,\n      );\n      return await this.start();\n    });\n  };\n\n  /**\n   * start scanner. first find fork point. fork all blocks and request updates from node.\n   */\n  start = async (): Promise<void> => {\n    this.stopped = false;\n    const context: InteractionContext = await createInteractionContext(\n      (err) => this.logger.error(`${err}`),\n      this.connectionCloseHandler,\n      { connection: { port: this.port, host: this.host, tls: this.useTls } },\n    );\n    const intersect = await this.findIntersection(context);\n    if (intersect) {\n      // find intersect then start from that point\n      this.client = await createChainSynchronizationClient(\n        context,\n        {\n          rollBackward: this.rollBackward,\n          rollForward: this.rollForward,\n        },\n        { sequential: true },\n      );\n      this.connected = true;\n      await this.forkBlock(intersect.height + 1);\n      await this.client.resume([intersect.point], 2);\n    } else {\n      throw Error('Can not start scanner. initial block is invalid');\n    }\n  };\n\n  /**\n   * stop ws connection to node.\n   */\n  stop = async (): Promise<void> => {\n    this.stopped = true;\n    await this.client.shutdown();\n  };\n\n  /**\n   * @returns The connection status of ogmios scanner\n   */\n  getConnectionStatus = () => this.connected;\n}\n\nexport { CardanoOgmiosScanner };\n"]}