@rosen-bridge/abstract-extractor 2.1.2 → 3.0.0-7b38188a

package/dist/ergo/database/entities/abstractErgoEntity.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Column, PrimaryGeneratedColumn, Unique, } from '@rosen-bridge/extended-typeorm';
+/**
+ * Abstract base entity for storing extracted blockchain data.
+ *
+ * This entity serves as the foundation for all extracted data storage,
+ * supporting both box-based and transaction-based extraction patterns.
+ * The identifier field can represent different types of blockchain data:
+ * - For box-based extractors: boxId (UTXO identifier)
+ * - For transaction-based extractors: txId (transaction identifier)
+ * - For general extractors: any unique blockchain data identifier
+ */
+let AbstractErgoEntity = class AbstractErgoEntity {
+    id;
+    block;
+    height;
+    extractor;
+    /**
+     * Unique identifier for the entity in the blockchain.
+     * This can be:
+     * - boxId for UTXO-based data (box extractors)
+     * - txId for transaction-based data (general extractors)
+     * - Any unique blockchain data identifier for custom extractors
+     */
+    identifier;
+    serialized;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], AbstractErgoEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "block", void 0);
+__decorate([
+    Column({ type: 'int' }),
+    __metadata("design:type", Number)
+], AbstractErgoEntity.prototype, "height", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "extractor", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "identifier", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "serialized", void 0);
+AbstractErgoEntity = __decorate([
+    Unique(['identifier', 'extractor'])
+], AbstractErgoEntity);
+export { AbstractErgoEntity };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+export * from './entities/abstractErgoBoxEntity';
+export * from './entities/abstractErgoEntity';
+export * from './actions/abstractErgoBoxAction';
+export * from './actions/abstractErgoAction';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/database/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC"}

package/dist/ergo/database/index.js

@@ -0,0 +1,5 @@
+export * from './entities/abstractErgoBoxEntity';
+export * from './entities/abstractErgoEntity';
+export * from './actions/abstractErgoBoxAction';
+export * from './actions/abstractErgoAction';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9kYXRhYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lbnRpdGllcy9hYnN0cmFjdEVyZ29Cb3hFbnRpdHknO1xuZXhwb3J0ICogZnJvbSAnLi9lbnRpdGllcy9hYnN0cmFjdEVyZ29FbnRpdHknO1xuZXhwb3J0ICogZnJvbSAnLi9hY3Rpb25zL2Fic3RyYWN0RXJnb0JveEFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbnMvYWJzdHJhY3RFcmdvQWN0aW9uJztcbiJdfQ==

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

@@ -0,0 +1,67 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { Transaction, BlockInfo, OutputBox, InputExtension } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoBoxEntity, AbstractErgoBoxAction } from '../database';
+import { AbstractEntityData, TxExtra, InitializeOptions } 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 declare abstract class AbstractErgoBoxExtractor<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoBoxEntity> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {
+    protected abstract actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>;
+    constructor(initializeOptions?: InitializeOptions, logger?: AbstractLogger);
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @param inputExtensions all input box extensions in transaction
+     * @return extracted data in proper format
+     */
+    abstract extractBoxData: (box: OutputBox, inputExtensions: InputExtension[], txExtra?: TxExtra) => ExtractedData | undefined;
+    /**
+     * check proper data format in the box
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    abstract hasBoxData: (box: OutputBox) => boolean;
+    /**
+     * extract transaction extra information
+     * override this function if there is extra needed information
+     * @param tx
+     * @returns
+     */
+    getTransactionExtraData: (tx: Transaction) => TxExtra;
+    /**
+     * create spend info array for the transaction
+     * @param tx
+     * @returns spend info array of the transaction
+     */
+    getTransactionSpendInfo: (tx: Transaction) => {
+        txId: string;
+        boxId: string;
+        index: number;
+    }[];
+    /**
+     * 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: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    /**
+     * initialize extractor database with data created below the initial height
+     * @param initialBlock
+     */
+    initializeData: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=abstractErgoBoxExtractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoBoxExtractor.d.ts","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoBoxExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,cAAc,EACf,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE3E,OAAO,EACL,kBAAkB,EAGlB,OAAO,EACP,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,wBAAwB,CAC5C,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,qBAAqB,CAC7C,SAAQ,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAC7D,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAC/C,aAAa,EACb,eAAe,CAChB,CAAC;gBAEU,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,cAAc;IAI1E;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,eAAe,EAAE,cAAc,EAAE,EACjC,OAAO,CAAC,EAAE,OAAO,KACd,aAAa,GAAG,SAAS,CAAC;IAE/B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAEjD;;;;;OAKG;IACH,uBAAuB,GACrB,IAAI,WAAW,KACd,OAAO,CAER;IAEF;;;;OAIG;IACH,uBAAuB,GAAI,IAAI,WAAW;;;;QAQxC;IAEF;;;;;OAKG;IACH,mBAAmB,GACjB,KAAK,WAAW,EAAE,EAClB,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CA2DjB;IAEF;;;OAGG;IACH,cAAc,GAAU,cAAc,SAAS,KAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;CACH"}

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,53 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+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> {
+    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>;
+}
+//# 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":"AAGA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE/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,CAAC;IAgBpC,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;CACH"}

package/dist/ergo/extractors/abstractErgoExtractor.js

@@ -0,0 +1,92 @@
+import { Mutex } from 'await-semaphore';
+import { v4 as uuidv4 } from 'uuid';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+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);
+    };
+}
+//# 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 { Mutex } from 'await-semaphore';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { Transaction } from '@rosen-bridge/scanner-interfaces';\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> {\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"]}

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) => 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,CAAC,EAAE,EAAE,WAAW,KAAK,aAAa,GAAG,SAAS,CAAC;IAEvE;;;;;;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);
+                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(`Initializiation 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":"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","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: (tx: Transaction) => 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);\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(`Initializiation 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=