@my-packages-changeit/abstract-extractor 3.2.3

package/dist/ergo/extractors/abstractErgoBoxExtractor.js

@@ -0,0 +1,106 @@
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { ErgoBoxInitializer } from '../initializers';
+import { CallbackType, } from '../interfaces';
+import { AbstractErgoExtractor } from './abstractErgoExtractor';
+/**
+ * Abstract Ergo Box Extractor class for box-based data extraction.
+ *
+ * This class extends the AbstractErgoExtractor class and provides
+ * functionality for extracting box-based data from the blockchain.
+ *
+ * It overrides the `initializeData` method to use the box-based initializer.
+ * It implements the `processTransactions` method to use the box-based data extraction.
+ *
+ * Triggers `Insert` callback on new data insertion.
+ * Triggers a new callback type `Spend` for each spent box.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export class AbstractErgoBoxExtractor extends AbstractErgoExtractor {
+    constructor(initializeOptions, logger) {
+        super(initializeOptions, logger);
+    }
+    /**
+     * extract transaction extra information
+     * override this function if there is extra needed information
+     * @param tx
+     * @returns
+     */
+    getTransactionExtraData = (tx) => {
+        return {};
+    };
+    /**
+     * create spend info array for the transaction
+     * @param tx
+     * @returns spend info array of the transaction
+     */
+    getTransactionSpendInfo = (tx) => {
+        let boxIndex = 1;
+        const spendInfoArray = [];
+        for (const input of tx.inputs) {
+            spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });
+            boxIndex += 1;
+        }
+        return spendInfoArray;
+    };
+    /**
+     * process a list of transactions in a block and store required information
+     * @param txs list of transactions in the block
+     * @param block
+     * @return true if the process is completed successfully and false otherwise
+     */
+    processTransactions = async (txs, block) => {
+        try {
+            const boxes = [];
+            const spentInfos = [];
+            for (const tx of txs) {
+                const inputExtensions = tx.inputs.map((input) => input.extension || {});
+                for (const output of tx.outputs) {
+                    if (!this.hasBoxData(output)) {
+                        continue;
+                    }
+                    this.logger.debug(`Trying to extract data from box ${output.boxId}`);
+                    const extractedData = this.extractBoxData(output, inputExtensions, this.getTransactionExtraData(tx));
+                    if (extractedData) {
+                        this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from box ${output.boxId}`);
+                        boxes.push(extractedData);
+                    }
+                }
+                spentInfos.push(...this.getTransactionSpendInfo(tx));
+            }
+            if (boxes.length > 0) {
+                if (!(await this.actions.storeEntities(boxes, block, this.getId()))) {
+                    this.logger.warn(`Data insertion failed for ${this.getId()} at the block ${block.height}`);
+                    return false;
+                }
+                this.triggerCallbacks(CallbackType.Insert, boxes);
+            }
+            const spentData = await this.actions.updateSpendingInfo(spentInfos, block, this.getId());
+            if (spentData.length > 0) {
+                this.triggerCallbacks(CallbackType.Spend, spentData);
+            }
+        }
+        catch (e) {
+            this.logger.error(`Processing transactions failed for ${this.getId()} at the block ${block.height} with error: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.error(`error stack: ${e.stack}`);
+            }
+            return false;
+        }
+        return true;
+    };
+    /**
+     * initialize extractor database with data created below the initial height
+     * @param initialBlock
+     */
+    initializeData = async (initialBlock) => {
+        if (this.initializeOptions && this.initializeOptions.active) {
+            const initializer = new ErgoBoxInitializer(this.initializeOptions.type, this.initializeOptions.url, this.initializeOptions.address, this.getId(), this.hasBoxData, this.processTransactions, this.actions, this.initializeOptions.maxParallelRequests, this.logger.child('ErgoBoxInitializer'));
+            await initializer.initializeData(initialBlock);
+        }
+        else
+            this.logger.info(`Initializiation for [${this.getId()}] is turned off`);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoBoxExtractor.js","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoBoxExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport {\n  Transaction,\n  BlockInfo,\n  OutputBox,\n  InputExtension,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractErgoBoxEntity, AbstractErgoBoxAction } from '../database';\nimport { ErgoBoxInitializer } from '../initializers';\nimport {\n  AbstractEntityData,\n  SpendInfo,\n  CallbackType,\n  TxExtra,\n  InitializeOptions,\n} from '../interfaces';\nimport { AbstractErgoExtractor } from './abstractErgoExtractor';\n\n/**\n * Abstract Ergo Box Extractor class for box-based data extraction.\n *\n * This class extends the AbstractErgoExtractor class and provides\n * functionality for extracting box-based data from the blockchain.\n *\n * It overrides the `initializeData` method to use the box-based initializer.\n * It implements the `processTransactions` method to use the box-based data extraction.\n *\n * Triggers `Insert` callback on new data insertion.\n * Triggers a new callback type `Spend` for each spent box.\n *\n * @template ExtractedData - The type of data extracted from blockchain\n * @template ExtractorEntity - The database entity type for storing extracted data\n */\nexport abstract class AbstractErgoBoxExtractor<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoBoxEntity,\n> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {\n  protected abstract actions: AbstractErgoBoxAction<\n    ExtractedData,\n    ExtractorEntity\n  >;\n\n  constructor(initializeOptions?: InitializeOptions, logger?: AbstractLogger) {\n    super(initializeOptions, logger);\n  }\n\n  /**\n   * extract box data to proper format (not including spending information)\n   * @param box\n   * @param inputExtensions all input box extensions in transaction\n   * @return extracted data in proper format\n   */\n  abstract extractBoxData: (\n    box: OutputBox,\n    inputExtensions: InputExtension[],\n    txExtra?: TxExtra,\n  ) => ExtractedData | undefined;\n\n  /**\n   * check proper data format in the box\n   * @param box\n   * @return true if the box has the required data and false otherwise\n   */\n  abstract hasBoxData: (box: OutputBox) => boolean;\n\n  /**\n   * extract transaction extra information\n   * override this function if there is extra needed information\n   * @param tx\n   * @returns\n   */\n  getTransactionExtraData = (\n    tx: Transaction, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): TxExtra => {\n    return {};\n  };\n\n  /**\n   * create spend info array for the transaction\n   * @param tx\n   * @returns spend info array of the transaction\n   */\n  getTransactionSpendInfo = (tx: Transaction) => {\n    let boxIndex = 1;\n    const spendInfoArray = [];\n    for (const input of tx.inputs) {\n      spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });\n      boxIndex += 1;\n    }\n    return spendInfoArray;\n  };\n\n  /**\n   * process a list of transactions in a block and store required information\n   * @param txs list of transactions in the block\n   * @param block\n   * @return true if the process is completed successfully and false otherwise\n   */\n  processTransactions = async (\n    txs: Transaction[],\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    try {\n      const boxes: Array<ExtractedData> = [];\n      const spentInfos: Array<SpendInfo> = [];\n      for (const tx of txs) {\n        const inputExtensions = tx.inputs.map((input) => input.extension || {});\n        for (const output of tx.outputs) {\n          if (!this.hasBoxData(output)) {\n            continue;\n          }\n          this.logger.debug(`Trying to extract data from box ${output.boxId}`);\n          const extractedData = this.extractBoxData(\n            output,\n            inputExtensions,\n            this.getTransactionExtraData(tx),\n          );\n          if (extractedData) {\n            this.logger.debug(\n              `Extracted data ${JsonBigInt.stringify(extractedData)} from box ${\n                output.boxId\n              }`,\n            );\n            boxes.push(extractedData);\n          }\n        }\n        spentInfos.push(...this.getTransactionSpendInfo(tx));\n      }\n\n      if (boxes.length > 0) {\n        if (!(await this.actions.storeEntities(boxes, block, this.getId()))) {\n          this.logger.warn(\n            `Data insertion failed for ${this.getId()} at the block ${\n              block.height\n            }`,\n          );\n          return false;\n        }\n        this.triggerCallbacks(CallbackType.Insert, boxes);\n      }\n      const spentData = await this.actions.updateSpendingInfo(\n        spentInfos,\n        block,\n        this.getId(),\n      );\n      if (spentData.length > 0) {\n        this.triggerCallbacks(CallbackType.Spend, spentData);\n      }\n    } catch (e) {\n      this.logger.error(\n        `Processing transactions failed for ${this.getId()} at the block ${\n          block.height\n        } with error: ${e}`,\n      );\n      if (e instanceof Error && e.stack) {\n        this.logger.error(`error stack: ${e.stack}`);\n      }\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * initialize extractor database with data created below the initial height\n   * @param initialBlock\n   */\n  initializeData = async (initialBlock: BlockInfo): Promise<void> => {\n    if (this.initializeOptions && this.initializeOptions.active) {\n      const initializer = new ErgoBoxInitializer(\n        this.initializeOptions.type,\n        this.initializeOptions.url,\n        this.initializeOptions.address,\n        this.getId(),\n        this.hasBoxData,\n        this.processTransactions,\n        this.actions,\n        this.initializeOptions.maxParallelRequests,\n        this.logger.child('ErgoBoxInitializer'),\n      );\n      await initializer.initializeData(initialBlock);\n    } else\n      this.logger.info(`Initializiation for [${this.getId()}] is turned off`);\n  };\n}\n"]}

package/dist/ergo/extractors/abstractErgoExtractor.d.ts

@@ -0,0 +1,61 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';
+import { Transaction } from '@rosen-bridge/scanner-interfaces';
+import { AbstractExtractor } from '../../abstractExtractor';
+import { AbstractErgoEntity, AbstractErgoAction } from '../database';
+import { AbstractEntityData, CallbackType, CallbackMap, CallbackDataMap, InitializeOptions } from '../interfaces';
+/**
+ * Abstract Ergo-specific extractor that provides common functionality for all Ergo extractors.
+ *
+ * It provides callback support and blockchain fork handle for all ergo extractors.
+ *
+ * It triggers callbacks for the `Update` and `Delete` actions on a forked block.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export declare abstract class AbstractErgoExtractor<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> extends AbstractExtractor<Transaction, ExtractorEntity> {
+    protected initializeOptions?: InitializeOptions | undefined;
+    protected logger: AbstractLogger;
+    protected abstract actions: AbstractErgoAction<ExtractedData, ExtractorEntity>;
+    protected callbacks: {
+        [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;
+    };
+    private callbackMutex;
+    constructor(initializeOptions?: InitializeOptions | undefined, logger?: AbstractLogger);
+    /**
+     * hook a new callback on a callback type
+     * @param type
+     * @param id
+     * @param callback
+     * @returns callback registered id
+     */
+    hook: <T extends CallbackType>(type: T, callback: CallbackMap<ExtractedData>[T]) => Promise<string>;
+    /**
+     * unhook a callback on a type
+     * returns false if there is no registered callback with the id
+     * @param type
+     * @param id
+     * @returns success status
+     */
+    unhook: (type: CallbackType, id: string) => Promise<boolean>;
+    /**
+     * trigger all callbacks registered on a specific type with the provided data
+     * @param type
+     * @param data
+     */
+    protected triggerCallbacks<T extends CallbackType>(type: T, data: CallbackDataMap<ExtractedData>[T]): void;
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash block hash
+     */
+    forkBlock: (hash: string) => Promise<void>;
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ExtractorEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery: () => SelectQueryBuilder<ExtractorEntity>;
+}
+//# sourceMappingURL=abstractErgoExtractor.d.ts.map

package/dist/ergo/extractors/abstractErgoExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoExtractor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAG/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;GASG;AACH,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB,CAC1C,SAAQ,iBAAiB,CAAC,WAAW,EAAE,eAAe,CAAC;IAgBrD,SAAS,CAAC,iBAAiB,CAAC,EAAE,iBAAiB;IAC/C,SAAS,CAAC,MAAM,EAAE,cAAc;IAhBlC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAC5C,aAAa,EACb,eAAe,CAChB,CAAC;IACF,SAAS,CAAC,SAAS,EAAE;SAClB,CAAC,IAAI,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;KAChE,CAKC;IACF,OAAO,CAAC,aAAa,CAAe;gBAGxB,iBAAiB,CAAC,EAAE,iBAAiB,YAAA,EACrC,MAAM,GAAE,cAAkC;IAKtD;;;;;;OAMG;IACH,IAAI,GAAU,CAAC,SAAS,YAAY,EAClC,MAAM,CAAC,EACP,UAAU,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KACtC,OAAO,CAAC,MAAM,CAAC,CAOhB;IAEF;;;;;;OAMG;IACH,MAAM,GAAU,MAAM,YAAY,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAY/D;IAEF;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,SAAS,YAAY,EAC/C,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GACtC,IAAI;IAaP;;;OAGG;IACH,SAAS,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CAM7C;IAEF;;;;;OAKG;IACH,qBAAqB,QAAO,kBAAkB,CAAC,eAAe,CAAC,CACZ;CACpD"}

package/dist/ergo/extractors/abstractErgoExtractor.js

@@ -0,0 +1,99 @@
+import { v4 as uuidv4 } from 'uuid';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { Mutex } from '@rosen-bridge/semaphore';
+import { AbstractExtractor } from '../../abstractExtractor';
+import { CallbackType, } from '../interfaces';
+/**
+ * Abstract Ergo-specific extractor that provides common functionality for all Ergo extractors.
+ *
+ * It provides callback support and blockchain fork handle for all ergo extractors.
+ *
+ * It triggers callbacks for the `Update` and `Delete` actions on a forked block.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export class AbstractErgoExtractor extends AbstractExtractor {
+    initializeOptions;
+    logger;
+    callbacks = {
+        [CallbackType.Update]: new Map(),
+        [CallbackType.Insert]: new Map(),
+        [CallbackType.Delete]: new Map(),
+        [CallbackType.Spend]: new Map(),
+    };
+    callbackMutex = new Mutex();
+    constructor(initializeOptions, logger = new DummyLogger()) {
+        super();
+        this.initializeOptions = initializeOptions;
+        this.logger = logger;
+    }
+    /**
+     * hook a new callback on a callback type
+     * @param type
+     * @param id
+     * @param callback
+     * @returns callback registered id
+     */
+    hook = async (type, callback) => {
+        const release = await this.callbackMutex.acquire();
+        const callbackMap = this.callbacks[type];
+        const id = uuidv4();
+        callbackMap.set(id, callback);
+        release();
+        return id;
+    };
+    /**
+     * unhook a callback on a type
+     * returns false if there is no registered callback with the id
+     * @param type
+     * @param id
+     * @returns success status
+     */
+    unhook = async (type, id) => {
+        const release = await this.callbackMutex.acquire();
+        const callbackMap = this.callbacks[type];
+        if (!callbackMap.has(id)) {
+            this.logger.warn(`Callback with Id [${id}] is not registered for type [${type}].`);
+            return false;
+        }
+        callbackMap.delete(id);
+        release();
+        return true;
+    };
+    /**
+     * trigger all callbacks registered on a specific type with the provided data
+     * @param type
+     * @param data
+     */
+    triggerCallbacks(type, data) {
+        const callbackMap = this.callbacks[type];
+        callbackMap.forEach((callback) => {
+            try {
+                callback(data);
+            }
+            catch (e) {
+                this.logger.warn(`callback failed for ${type} action on data [${data}] with error: ${e}`);
+            }
+        });
+    }
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash block hash
+     */
+    forkBlock = async (hash) => {
+        const result = await this.actions.deleteBlockData(hash, this.getId());
+        if (result.deletedData.length > 0)
+            this.triggerCallbacks(CallbackType.Delete, result.deletedData);
+        if (result.updatedData.length > 0)
+            this.triggerCallbacks(CallbackType.Update, result.updatedData);
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ExtractorEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = () => this.actions.createUsedBlocksQuery(this.getId());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoExtractor.js","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { v4 as uuidv4 } from 'uuid';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';\nimport { Transaction } from '@rosen-bridge/scanner-interfaces';\nimport { Mutex } from '@rosen-bridge/semaphore';\n\nimport { AbstractExtractor } from '../../abstractExtractor';\nimport { AbstractErgoEntity, AbstractErgoAction } from '../database';\nimport {\n  AbstractEntityData,\n  CallbackType,\n  CallbackMap,\n  CallbackDataMap,\n  InitializeOptions,\n} from '../interfaces';\n\n/**\n * Abstract Ergo-specific extractor that provides common functionality for all Ergo extractors.\n *\n * It provides callback support and blockchain fork handle for all ergo extractors.\n *\n * It triggers callbacks for the `Update` and `Delete` actions on a forked block.\n *\n * @template ExtractedData - The type of data extracted from blockchain\n * @template ExtractorEntity - The database entity type for storing extracted data\n */\nexport abstract class AbstractErgoExtractor<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoEntity,\n> extends AbstractExtractor<Transaction, ExtractorEntity> {\n  protected abstract actions: AbstractErgoAction<\n    ExtractedData,\n    ExtractorEntity\n  >;\n  protected callbacks: {\n    [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;\n  } = {\n    [CallbackType.Update]: new Map(),\n    [CallbackType.Insert]: new Map(),\n    [CallbackType.Delete]: new Map(),\n    [CallbackType.Spend]: new Map(),\n  };\n  private callbackMutex = new Mutex();\n\n  constructor(\n    protected initializeOptions?: InitializeOptions,\n    protected logger: AbstractLogger = new DummyLogger(),\n  ) {\n    super();\n  }\n\n  /**\n   * hook a new callback on a callback type\n   * @param type\n   * @param id\n   * @param callback\n   * @returns callback registered id\n   */\n  hook = async <T extends CallbackType>(\n    type: T,\n    callback: CallbackMap<ExtractedData>[T],\n  ): Promise<string> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    const id = uuidv4();\n    callbackMap.set(id, callback);\n    release();\n    return id;\n  };\n\n  /**\n   * unhook a callback on a type\n   * returns false if there is no registered callback with the id\n   * @param type\n   * @param id\n   * @returns success status\n   */\n  unhook = async (type: CallbackType, id: string): Promise<boolean> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    if (!callbackMap.has(id)) {\n      this.logger.warn(\n        `Callback with Id [${id}] is not registered for type [${type}].`,\n      );\n      return false;\n    }\n    callbackMap.delete(id);\n    release();\n    return true;\n  };\n\n  /**\n   * trigger all callbacks registered on a specific type with the provided data\n   * @param type\n   * @param data\n   */\n  protected triggerCallbacks<T extends CallbackType>(\n    type: T,\n    data: CallbackDataMap<ExtractedData>[T],\n  ): void {\n    const callbackMap = this.callbacks[type];\n    callbackMap.forEach((callback) => {\n      try {\n        callback(data);\n      } catch (e) {\n        this.logger.warn(\n          `callback failed for ${type} action on data [${data}] with error: ${e}`,\n        );\n      }\n    });\n  }\n\n  /**\n   * fork one block and remove all stored information for this block\n   * @param hash block hash\n   */\n  forkBlock = async (hash: string): Promise<void> => {\n    const result = await this.actions.deleteBlockData(hash, this.getId());\n    if (result.deletedData.length > 0)\n      this.triggerCallbacks(CallbackType.Delete, result.deletedData);\n    if (result.updatedData.length > 0)\n      this.triggerCallbacks(CallbackType.Update, result.updatedData);\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `ExtractorEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (): SelectQueryBuilder<ExtractorEntity> =>\n    this.actions.createUsedBlocksQuery(this.getId());\n}\n"]}

package/dist/ergo/extractors/abstractErgoTxExtractor.d.ts

@@ -0,0 +1,54 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoEntity } from '../database';
+import { AbstractEntityData, InitializeOptions } from '../interfaces';
+import { AbstractErgoExtractor } from './abstractErgoExtractor';
+/**
+ * Abstract Ergo Tx Extractor class for tx-based data extraction.
+ *
+ * This class extends the AbstractErgoExtractor class and provides
+ * functionality for extracting tx-based data from the blockchain.
+ *
+ * It implements the `initializeData` method with ergo initializers.
+ * It implements the `processTransactions` method to extract and
+ * store data from transactions.
+ *
+ * Triggers `Insert` callback on new data insertion.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export declare abstract class AbstractErgoTxExtractor<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {
+    constructor(initializeOptions?: InitializeOptions, logger?: AbstractLogger);
+    /**
+     * Extract transaction data to proper format (not including spending information).
+     * This method should be overridden by subclasses that need transaction-based extraction.
+     * @param tx - The transaction to extract data from
+     * @returns extracted data in proper format or undefined if no data should be extracted
+     * @throws Error if not overridden by subclass
+     */
+    abstract extractTxData: (tx: Transaction, block: BlockInfo) => ExtractedData | undefined;
+    /**
+     * Check if the transaction has the required data format.
+     * This method should be overridden by subclasses that need transaction-based extraction.
+     * @param tx - The transaction to check
+     * @returns true if the transaction has the required data and false otherwise
+     * @throws Error if not overridden by subclass
+     */
+    abstract hasTxData: (tx: Transaction) => boolean;
+    /**
+     * Process a list of transactions in a block and store required information.
+     * This method can be overridden by subclasses for custom transaction processing,
+     * or they can override extractTxData and hasTxData methods instead.
+     * @param txs - List of transactions in the block
+     * @param block - Block information
+     * @returns true if the process is completed successfully and false otherwise
+     */
+    processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    /**
+     * initialize extractor database with data created below the initial height
+     * @param initialBlock
+     */
+    initializeData: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=abstractErgoTxExtractor.d.ts.map

package/dist/ergo/extractors/abstractErgoTxExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoTxExtractor.d.ts","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoTxExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EACL,kBAAkB,EAElB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,uBAAuB,CAC3C,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB,CAC1C,SAAQ,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;gBACjD,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,cAAc;IAI1E;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,EAAE,CACtB,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,SAAS,KACb,aAAa,GAAG,SAAS,CAAC;IAE/B;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC;IAEjD;;;;;;;OAOG;IACH,mBAAmB,GACjB,KAAK,WAAW,EAAE,EAClB,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CA0CjB;IAEF;;;OAGG;IACH,cAAc,GAAU,cAAc,SAAS,KAAG,OAAO,CAAC,IAAI,CAAC,CAe7D;CACH"}

package/dist/ergo/extractors/abstractErgoTxExtractor.js

@@ -0,0 +1,76 @@
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { ErgoInitializer } from '../initializers';
+import { CallbackType, } from '../interfaces';
+import { AbstractErgoExtractor } from './abstractErgoExtractor';
+/**
+ * Abstract Ergo Tx Extractor class for tx-based data extraction.
+ *
+ * This class extends the AbstractErgoExtractor class and provides
+ * functionality for extracting tx-based data from the blockchain.
+ *
+ * It implements the `initializeData` method with ergo initializers.
+ * It implements the `processTransactions` method to extract and
+ * store data from transactions.
+ *
+ * Triggers `Insert` callback on new data insertion.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export class AbstractErgoTxExtractor extends AbstractErgoExtractor {
+    constructor(initializeOptions, logger) {
+        super(initializeOptions, logger);
+    }
+    /**
+     * Process a list of transactions in a block and store required information.
+     * This method can be overridden by subclasses for custom transaction processing,
+     * or they can override extractTxData and hasTxData methods instead.
+     * @param txs - List of transactions in the block
+     * @param block - Block information
+     * @returns true if the process is completed successfully and false otherwise
+     */
+    processTransactions = async (txs, block) => {
+        try {
+            const txsData = [];
+            for (const tx of txs) {
+                if (!this.hasTxData(tx)) {
+                    continue;
+                }
+                this.logger.debug(`Trying to extract data from tx [${tx.id}]`);
+                const extractedData = this.extractTxData(tx, block);
+                if (extractedData) {
+                    this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from tx ${tx.id}`);
+                    txsData.push(extractedData);
+                }
+            }
+            if (txsData.length > 0) {
+                if (!(await this.actions.storeEntities(txsData, block, this.getId()))) {
+                    this.logger.warn(`Data insertion failed for ${this.getId()} at the block ${block.height}`);
+                    return false;
+                }
+                this.triggerCallbacks(CallbackType.Insert, txsData);
+            }
+        }
+        catch (e) {
+            this.logger.error(`Processing transactions failed for ${this.getId()} at the block ${block.height} with error: ${e}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.debug(`error stack: ${e.stack}`);
+            }
+            return false;
+        }
+        return true;
+    };
+    /**
+     * initialize extractor database with data created below the initial height
+     * @param initialBlock
+     */
+    initializeData = async (initialBlock) => {
+        if (this.initializeOptions && this.initializeOptions.active) {
+            const initializer = new ErgoInitializer(this.initializeOptions.type, this.initializeOptions.url, this.initializeOptions.address, this.getId(), this.processTransactions, this.actions, this.initializeOptions.maxParallelRequests, this.logger.child('ErgoInitializer'));
+            await initializer.initializeData(initialBlock);
+        }
+        else
+            this.logger.info(`Initialization for [${this.getId()}] is turned off`);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoTxExtractor.js","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoTxExtractor.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,2BAA2B,CAAC;AAInD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAEL,YAAY,GAEb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAgB,uBAGpB,SAAQ,qBAAqD;IAC7D,YAAY,iBAAqC,EAAE,MAAuB;QACxE,KAAK,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IAuBD;;;;;;;OAOG;IACH,mBAAmB,GAAG,KAAK,EACzB,GAAkB,EAClB,KAAgB,EACE,EAAE;QACpB,IAAI,CAAC;YACH,MAAM,OAAO,GAAyB,EAAE,CAAC;YACzC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;gBACrB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;oBACxB,SAAS;gBACX,CAAC;gBACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;gBAC/D,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBACpD,IAAI,aAAa,EAAE,CAAC;oBAClB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,kBAAkB,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,YACnD,EAAE,CAAC,EACL,EAAE,CACH,CAAC;oBACF,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBAC9B,CAAC;YACH,CAAC;YAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;oBACtE,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,6BAA6B,IAAI,CAAC,KAAK,EAAE,iBACvC,KAAK,CAAC,MACR,EAAE,CACH,CAAC;oBACF,OAAO,KAAK,CAAC;gBACf,CAAC;gBACD,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,sCAAsC,IAAI,CAAC,KAAK,EAAE,iBAChD,KAAK,CAAC,MACR,gBAAgB,CAAC,EAAE,CACpB,CAAC;YACF,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;YAC/C,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF;;;OAGG;IACH,cAAc,GAAG,KAAK,EAAE,YAAuB,EAAiB,EAAE;QAChE,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC;YAC5D,MAAM,WAAW,GAAG,IAAI,eAAe,CACrC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAC3B,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAC1B,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAC9B,IAAI,CAAC,KAAK,EAAE,EACZ,IAAI,CAAC,mBAAmB,EACxB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,EAC1C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CACrC,CAAC;YACF,MAAM,WAAW,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QACjD,CAAC;;YACC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IAC3E,CAAC,CAAC;CACH","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractErgoEntity } from '../database';\nimport { ErgoInitializer } from '../initializers';\nimport {\n  AbstractEntityData,\n  CallbackType,\n  InitializeOptions,\n} from '../interfaces';\nimport { AbstractErgoExtractor } from './abstractErgoExtractor';\n\n/**\n * Abstract Ergo Tx Extractor class for tx-based data extraction.\n *\n * This class extends the AbstractErgoExtractor class and provides\n * functionality for extracting tx-based data from the blockchain.\n *\n * It implements the `initializeData` method with ergo initializers.\n * It implements the `processTransactions` method to extract and\n * store data from transactions.\n *\n * Triggers `Insert` callback on new data insertion.\n *\n * @template ExtractedData - The type of data extracted from blockchain\n * @template ExtractorEntity - The database entity type for storing extracted data\n */\nexport abstract class AbstractErgoTxExtractor<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoEntity,\n> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {\n  constructor(initializeOptions?: InitializeOptions, logger?: AbstractLogger) {\n    super(initializeOptions, logger);\n  }\n\n  /**\n   * Extract transaction data to proper format (not including spending information).\n   * This method should be overridden by subclasses that need transaction-based extraction.\n   * @param tx - The transaction to extract data from\n   * @returns extracted data in proper format or undefined if no data should be extracted\n   * @throws Error if not overridden by subclass\n   */\n  abstract extractTxData: (\n    tx: Transaction,\n    block: BlockInfo,\n  ) => ExtractedData | undefined;\n\n  /**\n   * Check if the transaction has the required data format.\n   * This method should be overridden by subclasses that need transaction-based extraction.\n   * @param tx - The transaction to check\n   * @returns true if the transaction has the required data and false otherwise\n   * @throws Error if not overridden by subclass\n   */\n  abstract hasTxData: (tx: Transaction) => boolean;\n\n  /**\n   * Process a list of transactions in a block and store required information.\n   * This method can be overridden by subclasses for custom transaction processing,\n   * or they can override extractTxData and hasTxData methods instead.\n   * @param txs - List of transactions in the block\n   * @param block - Block information\n   * @returns true if the process is completed successfully and false otherwise\n   */\n  processTransactions = async (\n    txs: Transaction[],\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    try {\n      const txsData: Array<ExtractedData> = [];\n      for (const tx of txs) {\n        if (!this.hasTxData(tx)) {\n          continue;\n        }\n        this.logger.debug(`Trying to extract data from tx [${tx.id}]`);\n        const extractedData = this.extractTxData(tx, block);\n        if (extractedData) {\n          this.logger.debug(\n            `Extracted data ${JsonBigInt.stringify(extractedData)} from tx ${\n              tx.id\n            }`,\n          );\n          txsData.push(extractedData);\n        }\n      }\n\n      if (txsData.length > 0) {\n        if (!(await this.actions.storeEntities(txsData, block, this.getId()))) {\n          this.logger.warn(\n            `Data insertion failed for ${this.getId()} at the block ${\n              block.height\n            }`,\n          );\n          return false;\n        }\n        this.triggerCallbacks(CallbackType.Insert, txsData);\n      }\n    } catch (e) {\n      this.logger.error(\n        `Processing transactions failed for ${this.getId()} at the block ${\n          block.height\n        } with error: ${e}`,\n      );\n      if (e instanceof Error && e.stack) {\n        this.logger.debug(`error stack: ${e.stack}`);\n      }\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * initialize extractor database with data created below the initial height\n   * @param initialBlock\n   */\n  initializeData = async (initialBlock: BlockInfo): Promise<void> => {\n    if (this.initializeOptions && this.initializeOptions.active) {\n      const initializer = new ErgoInitializer(\n        this.initializeOptions.type,\n        this.initializeOptions.url,\n        this.initializeOptions.address,\n        this.getId(),\n        this.processTransactions,\n        this.actions,\n        this.initializeOptions.maxParallelRequests,\n        this.logger.child('ErgoInitializer'),\n      );\n      await initializer.initializeData(initialBlock);\n    } else\n      this.logger.info(`Initialization for [${this.getId()}] is turned off`);\n  };\n}\n"]}

package/dist/ergo/extractors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abstractErgoExtractor';
+export * from './abstractErgoBoxExtractor';
+export * from './abstractErgoTxExtractor';
+//# sourceMappingURL=index.d.ts.map

package/dist/ergo/extractors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/extractors/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}

package/dist/ergo/extractors/index.js

@@ -0,0 +1,4 @@
+export * from './abstractErgoExtractor';
+export * from './abstractErgoBoxExtractor';
+export * from './abstractErgoTxExtractor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9leHRyYWN0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29FeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29Cb3hFeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29UeEV4dHJhY3Rvcic7XG4iXX0=

package/dist/ergo/index.d.ts

@@ -0,0 +1,8 @@
+export * from './extractors';
+export * from './initializers';
+export * from './database';
+export * from './interfaces';
+export * from './networks';
+export * from './initializers';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/ergo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC"}

package/dist/ergo/index.js

@@ -0,0 +1,8 @@
+export * from './extractors';
+export * from './initializers';
+export * from './database';
+export * from './interfaces';
+export * from './networks';
+export * from './initializers';
+export * from './utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V4dHJhY3RvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXplcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhYmFzZSc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3Jrcyc7XG5leHBvcnQgKiBmcm9tICcuL2luaXRpYWxpemVycyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbiJdfQ==

package/dist/ergo/initializers/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DELAY_BETWEEN_INIT_REQUESTS = 100;
+export declare const INIT_WORKERS_REASSIGN_INTERVAL = 5000;
+export declare const MAX_PARALLEL_REQUESTS = 10;
+//# sourceMappingURL=constants.d.ts.map

package/dist/ergo/initializers/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializers/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,8BAA8B,OAAO,CAAC;AACnD,eAAO,MAAM,qBAAqB,KAAK,CAAC"}

package/dist/ergo/initializers/constants.js

@@ -0,0 +1,4 @@
+export const DELAY_BETWEEN_INIT_REQUESTS = 100; // In milliseconds (only applies to node initialization)
+export const INIT_WORKERS_REASSIGN_INTERVAL = 5000; //milliseconds (only applies to explorer initialization)
+export const MAX_PARALLEL_REQUESTS = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL2VyZ28vaW5pdGlhbGl6ZXJzL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRyxHQUFHLENBQUMsQ0FBQyx3REFBd0Q7QUFDeEcsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQUcsSUFBSSxDQUFDLENBQUMsd0RBQXdEO0FBQzVHLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBERUxBWV9CRVRXRUVOX0lOSVRfUkVRVUVTVFMgPSAxMDA7IC8vIEluIG1pbGxpc2Vjb25kcyAob25seSBhcHBsaWVzIHRvIG5vZGUgaW5pdGlhbGl6YXRpb24pXG5leHBvcnQgY29uc3QgSU5JVF9XT1JLRVJTX1JFQVNTSUdOX0lOVEVSVkFMID0gNTAwMDsgLy9taWxsaXNlY29uZHMgKG9ubHkgYXBwbGllcyB0byBleHBsb3JlciBpbml0aWFsaXphdGlvbilcbmV4cG9ydCBjb25zdCBNQVhfUEFSQUxMRUxfUkVRVUVTVFMgPSAxMDtcbiJdfQ==

package/dist/ergo/initializers/ergoBoxInitializer.d.ts

@@ -0,0 +1,36 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, ErgoNetworkType, OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoBoxAction, AbstractErgoEntity } from '../database';
+import { AbstractEntityData, ExtendedSpendInfo, ExtendedTransaction } from '../interfaces';
+import { ErgoInitializer } from './ergoInitializer';
+export declare class ErgoBoxInitializer<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> extends ErgoInitializer<ExtractedData, ExtractorEntity> {
+    protected extractorId: string;
+    protected hasBoxData: (box: OutputBox) => boolean;
+    protected processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    protected actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>;
+    protected logger: AbstractLogger;
+    private spendRecordsMutex;
+    private spendRecords;
+    constructor(networkType: ErgoNetworkType, url: string, address: string, extractorId: string, hasBoxData: (box: OutputBox) => boolean, processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>, actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>, maxParallelRequests?: number, logger?: AbstractLogger);
+    /**
+     * Extracts spending information of all related boxes in the transaction
+     * Note: override this function if the extractor needs extra spending info
+     * @param tx
+     * @returns transaction spend info
+     */
+    protected extractTxSpendInfo: (tx: ExtendedTransaction) => ExtendedSpendInfo[];
+    /**
+     * Extract and store all spending information of a transaction batch
+     * @param txs
+     */
+    protected storeExtraInfo: (txs: ExtendedTransaction[]) => Promise<void>;
+    /**
+     * Apply stored spend records into extractor database
+     * Note: As transactions are processed out of order (due to parallel
+     * processing), some box spend information may be invalid after the first pass
+     * To avoid processing everything twice, we keep all spend records in the
+     * first pass and reapply them at the end
+     */
+    protected applyExtraInfo: () => Promise<void>;
+}
+//# sourceMappingURL=ergoBoxInitializer.d.ts.map

package/dist/ergo/initializers/ergoBoxInitializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ergoBoxInitializer.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializers/ergoBoxInitializer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,SAAS,EACT,eAAe,EACf,SAAS,EACT,WAAW,EACZ,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,kBAAkB,CAC7B,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB,CAC1C,SAAQ,eAAe,CAAC,aAAa,EAAE,eAAe,CAAC;IAQrD,SAAS,CAAC,WAAW,EAAE,MAAM;IAC7B,SAAS,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO;IACjD,SAAS,CAAC,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC;IACrB,SAAS,CAAC,OAAO,EAAE,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAExE,SAAS,CAAC,MAAM,EAAE,cAAc;IAflC,OAAO,CAAC,iBAAiB,CAAe;IACxC,OAAO,CAAC,YAAY,CAAsB;gBAGxC,WAAW,EAAE,eAAe,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACL,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,EACvC,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC,EACX,OAAO,EAAE,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC,EACxE,mBAAmB,SAAwB,EACjC,MAAM,GAAE,cAAkC;IAetD;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAC1B,IAAI,mBAAmB,KACtB,iBAAiB,EAAE,CAepB;IAEF;;;OAGG;IACH,SAAS,CAAC,cAAc,GACtB,KAAK,mBAAmB,EAAE,KACzB,OAAO,CAAC,IAAI,CAAC,CASd;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,sBAuBtB;CACH"}