@my-packages-changeit/watcher-data-extractor 13.0.10

package/dist/extractor/commitmentExtractor.js

@@ -0,0 +1,125 @@
+import * as wasm from 'ergo-lib-wasm-nodejs';
+import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import CommitmentAction from '../actions/commitmentAction';
+import { JsonBI } from '../utils';
+class CommitmentExtractor extends AbstractExtractor {
+    logger;
+    id;
+    dataSource;
+    commitmentsErgoTrees;
+    RWTId;
+    actions;
+    tokenMap;
+    constructor(id, addresses, RWTId, dataSource, tokens, logger) {
+        super();
+        this.id = id;
+        this.dataSource = dataSource;
+        this.commitmentsErgoTrees = addresses.map((address) => wasm.Address.from_base58(address).to_ergo_tree().to_base16_bytes());
+        this.RWTId = RWTId;
+        this.logger = logger ? logger : new DummyLogger();
+        this.actions = new CommitmentAction(dataSource, this.logger.child('CommitmentAction'));
+        this.tokenMap = tokens;
+    }
+    /**
+     * get Id for current extractor
+     */
+    getId = () => this.id;
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param txs
+     * @param block
+     */
+    processTransactions = (txs, block) => {
+        return new Promise((resolve, reject) => {
+            try {
+                const commitments = [];
+                const spendIds = [];
+                txs.forEach((transaction) => {
+                    // process outputs
+                    for (const output of transaction.outputs) {
+                        if (output.assets &&
+                            output.additionalRegisters &&
+                            output.assets.length > 0 &&
+                            output.assets[0].tokenId === this.RWTId &&
+                            this.commitmentsErgoTrees.indexOf(output.ergoTree) !== -1) {
+                            try {
+                                const decodedBox = wasm.ErgoBox.from_json(JsonBI.stringify(output));
+                                const R4 = decodedBox.register_value(wasm.NonMandatoryRegisterId.R4);
+                                const R5 = decodedBox.register_value(wasm.NonMandatoryRegisterId.R5);
+                                const R6 = decodedBox.register_value(wasm.NonMandatoryRegisterId.R6);
+                                if (R4 && R5 && R6) {
+                                    const R4Value = R4.to_byte_array();
+                                    const R5Value = R5.to_byte_array();
+                                    const R6Value = R6.to_byte_array();
+                                    const WID = Buffer.from(R4Value).toString('hex');
+                                    const requestId = Buffer.from(R5Value).toString('hex');
+                                    const eventDigest = Buffer.from(R6Value).toString('hex');
+                                    commitments.push({
+                                        txId: transaction.id,
+                                        WID: WID,
+                                        commitment: eventDigest,
+                                        eventId: requestId,
+                                        boxId: output.boxId,
+                                        boxSerialized: Buffer.from(decodedBox.sigma_serialize_bytes()).toString('base64'),
+                                        rwtCount: this.tokenMap
+                                            .wrapAmount(this.RWTId, BigInt(output.assets[0].amount), 'ergo')
+                                            .amount.toString(),
+                                    });
+                                }
+                            }
+                            catch {
+                                // empty
+                            }
+                        }
+                    }
+                    // process inputs
+                    for (let i = 0; i < transaction.inputs.length; i++) {
+                        spendIds.push({
+                            boxId: transaction.inputs[i].boxId,
+                            txId: transaction.id,
+                            index: i,
+                        });
+                    }
+                });
+                // process save commitments
+                this.actions
+                    .storeCommitments(commitments, block, this.id)
+                    .then(() => {
+                    this.actions.spendCommitments(spendIds, block, this.id).then(() => {
+                        resolve(true);
+                    });
+                })
+                    .catch((e) => reject(e));
+            }
+            catch (e) {
+                this.logger.error(`Error in soring permits of the block ${block}: ${e}`);
+                reject(e);
+            }
+        });
+    };
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash: block hash
+     */
+    forkBlock = async (hash) => {
+        await this.actions.deleteBlock(hash, this.getId());
+    };
+    /**
+     * Extractor box initialization
+     * No action needed for commitment extractor
+     */
+    initializeData = async () => {
+        return;
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `CommitmentEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = () => this.actions.createUsedBlocksQuery(this.getId());
+}
+export default CommitmentExtractor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commitmentExtractor.js","sourceRoot":"","sources":["../../lib/extractor/commitmentExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as wasm from 'ergo-lib-wasm-nodejs';\n\nimport { AbstractExtractor } from '@rosen-bridge/abstract-extractor';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { DataSource, SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';\nimport { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';\nimport { TokenMap } from '@rosen-bridge/tokens';\n\nimport CommitmentAction from '../actions/commitmentAction';\nimport CommitmentEntity from '../entities/commitmentEntity';\nimport { extractedCommitment } from '../interfaces/extractedCommitment';\nimport { SpendInfo } from '../interfaces/types';\nimport { JsonBI } from '../utils';\n\nclass CommitmentExtractor extends AbstractExtractor<\n  Transaction,\n  CommitmentEntity\n> {\n  readonly logger: AbstractLogger;\n  id: string;\n  private readonly dataSource: DataSource;\n  private readonly commitmentsErgoTrees: Array<string>;\n  private readonly RWTId: string;\n  private readonly actions: CommitmentAction;\n  private readonly tokenMap: TokenMap;\n\n  constructor(\n    id: string,\n    addresses: Array<string>,\n    RWTId: string,\n    dataSource: DataSource,\n    tokens: TokenMap,\n    logger?: AbstractLogger,\n  ) {\n    super();\n    this.id = id;\n    this.dataSource = dataSource;\n    this.commitmentsErgoTrees = addresses.map((address) =>\n      wasm.Address.from_base58(address).to_ergo_tree().to_base16_bytes(),\n    );\n    this.RWTId = RWTId;\n    this.logger = logger ? logger : new DummyLogger();\n    this.actions = new CommitmentAction(\n      dataSource,\n      this.logger.child('CommitmentAction'),\n    );\n    this.tokenMap = tokens;\n  }\n\n  /**\n   * get Id for current extractor\n   */\n  getId = () => this.id;\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param txs\n   * @param block\n   */\n  processTransactions = (\n    txs: Array<Transaction>,\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    return new Promise((resolve, reject) => {\n      try {\n        const commitments: Array<extractedCommitment> = [];\n        const spendIds: Array<SpendInfo> = [];\n        txs.forEach((transaction) => {\n          // process outputs\n          for (const output of transaction.outputs) {\n            if (\n              output.assets &&\n              output.additionalRegisters &&\n              output.assets.length > 0 &&\n              output.assets[0].tokenId === this.RWTId &&\n              this.commitmentsErgoTrees.indexOf(output.ergoTree) !== -1\n            ) {\n              try {\n                const decodedBox = wasm.ErgoBox.from_json(\n                  JsonBI.stringify(output),\n                );\n                const R4 = decodedBox.register_value(\n                  wasm.NonMandatoryRegisterId.R4,\n                );\n                const R5 = decodedBox.register_value(\n                  wasm.NonMandatoryRegisterId.R5,\n                );\n                const R6 = decodedBox.register_value(\n                  wasm.NonMandatoryRegisterId.R6,\n                );\n                if (R4 && R5 && R6) {\n                  const R4Value = R4.to_byte_array();\n                  const R5Value = R5.to_byte_array();\n                  const R6Value = R6.to_byte_array();\n                  const WID = Buffer.from(R4Value).toString('hex');\n                  const requestId = Buffer.from(R5Value).toString('hex');\n                  const eventDigest = Buffer.from(R6Value).toString('hex');\n                  commitments.push({\n                    txId: transaction.id,\n                    WID: WID,\n                    commitment: eventDigest,\n                    eventId: requestId,\n                    boxId: output.boxId,\n                    boxSerialized: Buffer.from(\n                      decodedBox.sigma_serialize_bytes(),\n                    ).toString('base64'),\n                    rwtCount: this.tokenMap\n                      .wrapAmount(\n                        this.RWTId,\n                        BigInt(output.assets[0].amount),\n                        'ergo',\n                      )\n                      .amount.toString(),\n                  });\n                }\n              } catch {\n                // empty\n              }\n            }\n          }\n          // process inputs\n          for (let i = 0; i < transaction.inputs.length; i++) {\n            spendIds.push({\n              boxId: transaction.inputs[i].boxId,\n              txId: transaction.id,\n              index: i,\n            });\n          }\n        });\n        // process save commitments\n        this.actions\n          .storeCommitments(commitments, block, this.id)\n          .then(() => {\n            this.actions.spendCommitments(spendIds, block, this.id).then(() => {\n              resolve(true);\n            });\n          })\n          .catch((e) => reject(e));\n      } catch (e) {\n        this.logger.error(\n          `Error in soring permits of the block ${block}: ${e}`,\n        );\n        reject(e);\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    await this.actions.deleteBlock(hash, this.getId());\n  };\n\n  /**\n   * Extractor box initialization\n   * No action needed for commitment extractor\n   */\n  initializeData = async () => {\n    return;\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `CommitmentEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (): SelectQueryBuilder<CommitmentEntity> =>\n    this.actions.createUsedBlocksQuery(this.getId());\n}\n\nexport default CommitmentExtractor;\n"]}

package/dist/extractor/eventTriggerExtractor.d.ts

@@ -0,0 +1,57 @@
+import { AbstractErgoBoxExtractor } from '@rosen-bridge/abstract-extractor';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo, ErgoNetworkType, OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';
+import EventTriggerAction from '../actions/eventTriggerAction';
+import EventTriggerEntity from '../entities/eventTriggerEntity';
+import { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';
+import { EventResult } from '../types';
+declare class EventTriggerExtractor extends AbstractErgoBoxExtractor<ExtractedEventTrigger, EventTriggerEntity> {
+    id: string;
+    protected readonly actions: EventTriggerAction;
+    private readonly eventTriggerErgoTree;
+    private readonly permitErgoTree;
+    private readonly fraudErgoTree;
+    private readonly RWT;
+    constructor(id: string, dataSource: DataSource, type: ErgoNetworkType, url: string, address: string, RWT: string, permitAddress: string, fraudAddress: string, logger?: AbstractLogger, initialize?: boolean);
+    /**
+     * get Id for current extractor
+     */
+    getId: () => string;
+    /**
+     * check proper data format in the box
+     *  - box ergoTree
+     *  - RWT in first token place
+     *  - widListHash in R4
+     *  - event data in R5
+     *  - widCount in R7
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    hasBoxData: (box: OutputBox) => boolean;
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @return extracted data in proper format
+     */
+    extractBoxData: (box: OutputBox) => Omit<ExtractedEventTrigger, "spendBlock" | "spendHeight"> | undefined;
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param block
+     * @param txs
+     */
+    processTransactions: (txs: Array<Transaction>, block: BlockInfo) => Promise<boolean>;
+    /**
+     * extracts result and paymentTxId from a transaction
+     * returns 'unknown' as result when tx is neither fraud or successful
+     * @param transaction
+     * @returns
+     */
+    protected extractEventResult: (transaction: Transaction) => {
+        result: EventResult;
+        paymentTxId: string;
+    };
+}
+export default EventTriggerExtractor;
+//# sourceMappingURL=eventTriggerExtractor.d.ts.map

package/dist/extractor/eventTriggerExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventTriggerExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/eventTriggerExtractor.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EAGzB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EACL,SAAS,EACT,eAAe,EACf,SAAS,EACT,WAAW,EACZ,MAAM,kCAAkC,CAAC;AAE1C,OAAO,kBAAkB,MAAM,+BAA+B,CAAC;AAC/D,OAAO,kBAAkB,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,cAAM,qBAAsB,SAAQ,wBAAwB,CAC1D,qBAAqB,EACrB,kBAAkB,CACnB;IACC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IAC/C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAG3B,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,UAAO;IAoBnB;;OAEG;IACH,KAAK,eAAiB;IAEtB;;;;;;;;;OASG;IACH,UAAU,GAAI,KAAK,SAAS,KAAG,OAAO,CA2BpC;IAEF;;;;OAIG;IACH,cAAc,GACZ,KAAK,SAAS,KACb,IAAI,CAAC,qBAAqB,EAAE,YAAY,GAAG,aAAa,CAAC,GAAG,SAAS,CAwDtE;IAEF;;;;;OAKG;IACH,mBAAmB,GACjB,KAAK,KAAK,CAAC,WAAW,CAAC,EACvB,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CAyDjB;IAEF;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAAI,aAAa,WAAW;;;MA0CtD;CACH;AAED,eAAe,qBAAqB,CAAC"}

package/dist/extractor/eventTriggerExtractor.js

@@ -0,0 +1,215 @@
+import { blake2b } from 'blakejs';
+import * as wasm from 'ergo-lib-wasm-nodejs';
+import { AbstractErgoBoxExtractor, CallbackType, } from '@rosen-bridge/abstract-extractor';
+import EventTriggerAction from '../actions/eventTriggerAction';
+import { EventResult } from '../types';
+import { JsonBI } from '../utils';
+class EventTriggerExtractor extends AbstractErgoBoxExtractor {
+    id;
+    actions;
+    eventTriggerErgoTree;
+    permitErgoTree;
+    fraudErgoTree;
+    RWT;
+    constructor(id, dataSource, type, url, address, RWT, permitAddress, fraudAddress, logger, initialize = true) {
+        super({ type, url, address, active: initialize }, logger);
+        this.id = id;
+        this.eventTriggerErgoTree = wasm.Address.from_base58(address)
+            .to_ergo_tree()
+            .to_base16_bytes();
+        this.permitErgoTree = wasm.Address.from_base58(permitAddress)
+            .to_ergo_tree()
+            .to_base16_bytes();
+        this.fraudErgoTree = wasm.Address.from_base58(fraudAddress)
+            .to_ergo_tree()
+            .to_base16_bytes();
+        this.RWT = RWT;
+        this.actions = new EventTriggerAction(dataSource, this.logger.child('EventTriggerAction'));
+    }
+    /**
+     * get Id for current extractor
+     */
+    getId = () => this.id;
+    /**
+     * check proper data format in the box
+     *  - box ergoTree
+     *  - RWT in first token place
+     *  - widListHash in R4
+     *  - event data in R5
+     *  - widCount in R7
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    hasBoxData = (box) => {
+        try {
+            if (box.additionalRegisters &&
+                box.additionalRegisters.R4 &&
+                box.additionalRegisters.R5 &&
+                box.additionalRegisters.R7 &&
+                box.assets &&
+                box.assets.length > 0 &&
+                box.assets[0].tokenId === this.RWT &&
+                box.ergoTree === this.eventTriggerErgoTree) {
+                const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+                const R4Serialized = parsedBox
+                    .register_value(wasm.NonMandatoryRegisterId.R4)
+                    .to_byte_array();
+                const R5Serialized = parsedBox
+                    .register_value(wasm.NonMandatoryRegisterId.R5)
+                    .to_coll_coll_byte();
+                if (R4Serialized.length >= 1 && R5Serialized.length >= 12)
+                    return true;
+            }
+        }
+        catch (e) {
+            this.logger.warn(`Unexpected error occurred while checking the proper trigger data format for box ${box.boxId}: ${e}`);
+        }
+        return false;
+    };
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @return extracted data in proper format
+     */
+    extractBoxData = (box) => {
+        try {
+            const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+            const R4Serialized = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R4)
+                .to_byte_array();
+            const R5Serialized = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R5)
+                .to_coll_coll_byte();
+            const WIDsCount = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R7)
+                .to_i32();
+            const WIDsHash = Buffer.from(R4Serialized).toString('hex');
+            const sourceTxId = Buffer.from(R5Serialized[0]).toString();
+            const eventId = Buffer.from(blake2b(sourceTxId, undefined, 32)).toString('hex');
+            return {
+                eventId: eventId,
+                txId: box.transactionId,
+                identifier: box.boxId,
+                serialized: Buffer.from(parsedBox.sigma_serialize_bytes()).toString('base64'),
+                toChain: Buffer.from(R5Serialized[2]).toString(),
+                toAddress: Buffer.from(R5Serialized[4]).toString(),
+                networkFee: BigInt('0x' + Buffer.from(R5Serialized[7]).toString('hex')).toString(10),
+                bridgeFee: BigInt('0x' + Buffer.from(R5Serialized[6]).toString('hex')).toString(10),
+                amount: BigInt('0x' + Buffer.from(R5Serialized[5]).toString('hex')).toString(10),
+                sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),
+                targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),
+                sourceTxId: sourceTxId,
+                fromChain: Buffer.from(R5Serialized[1]).toString(),
+                fromAddress: Buffer.from(R5Serialized[3]).toString(),
+                sourceBlockId: Buffer.from(R5Serialized[10]).toString(),
+                WIDsCount: WIDsCount,
+                WIDsHash: WIDsHash,
+                sourceChainHeight: Number(BigInt('0x' + Buffer.from(R5Serialized[11]).toString('hex')).toString(10)),
+            };
+        }
+        catch (e) {
+            this.logger.warn(`Unexpected error occurred while extracting trigger data for box ${box.boxId}: ${e}`);
+            return undefined;
+        }
+    };
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param block
+     * @param txs
+     */
+    processTransactions = async (txs, block) => {
+        try {
+            const boxes = [];
+            const spendInfoArray = [];
+            txs.forEach((transaction) => {
+                // extract event result
+                const { result, paymentTxId } = this.extractEventResult(transaction);
+                for (const output of transaction.outputs) {
+                    // extract output box data
+                    if (this.hasBoxData(output)) {
+                        this.logger.debug(`Trying to extract data from box ${output.boxId} at height ${block.height}`);
+                        const data = this.extractBoxData(output);
+                        if (data) {
+                            this.logger.debug(`Extracted data ${JsonBI.stringify(data)} from box ${output.boxId}`);
+                            boxes.push(data);
+                        }
+                    }
+                }
+                // process inputs
+                for (let index = 0; index < transaction.inputs.length; index++)
+                    spendInfoArray.push({
+                        txId: transaction.id,
+                        boxId: transaction.inputs[index].boxId,
+                        index: index,
+                        extras: { result, paymentTxId },
+                    });
+            });
+            if (boxes.length > 0) {
+                if (!(await this.actions.storeEntities(boxes, block, this.getId()))) {
+                    this.logger.warn(`Data insertion failed at height ${block.height} for extractor ${this.id}`);
+                    return false;
+                }
+                this.triggerCallbacks(CallbackType.Insert, boxes);
+            }
+            const spentData = await this.actions.spendBoxes(spendInfoArray, block, this.id);
+            this.triggerCallbacks(CallbackType.Spend, spentData);
+        }
+        catch (e) {
+            this.logger.error(`Error in storing data in ${this.getId()} of the block ${block.height}: ${e}`);
+            return false;
+        }
+        return true;
+    };
+    /**
+     * extracts result and paymentTxId from a transaction
+     * returns 'unknown' as result when tx is neither fraud or successful
+     * @param transaction
+     * @returns
+     */
+    extractEventResult = (transaction) => {
+        let result = EventResult.unknown;
+        let paymentTxId = '';
+        if (transaction.outputs[0].ergoTree === this.fraudErgoTree)
+            result = EventResult.fraud;
+        else if (transaction.outputs[0].ergoTree === this.permitErgoTree) {
+            result = EventResult.successful;
+            // find first non-watcher box with R4 value
+            for (const box of transaction.outputs) {
+                // if it's watcher box, skip it
+                if (box.ergoTree === this.permitErgoTree)
+                    continue;
+                const outputParsed = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+                try {
+                    const R4Serialized = outputParsed
+                        .register_value(wasm.NonMandatoryRegisterId.R4)
+                        ?.to_byte_array();
+                    if (R4Serialized !== undefined) {
+                        let txId = Buffer.from(R4Serialized).toString();
+                        // we assumed txId only includes these characters
+                        if (!txId.match(/^[0-9a-zA-Z\-_.]+$/)) {
+                            // backward compatibility
+                            txId = Buffer.from(R4Serialized).toString('hex');
+                        }
+                        paymentTxId = txId;
+                        if (txId === '') {
+                            paymentTxId = transaction.id;
+                            this.logger.debug(`successful event is spent. tx [${transaction.id}] is both payment and reward distribution tx`);
+                        }
+                        // paymentTxId is extracted. no need to process next boxes
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return {
+            result,
+            paymentTxId,
+        };
+    };
+}
+export default EventTriggerExtractor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventTriggerExtractor.js","sourceRoot":"","sources":["../../lib/extractor/eventTriggerExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { blake2b } from 'blakejs';\nimport * as wasm from 'ergo-lib-wasm-nodejs';\n\nimport {\n  AbstractErgoBoxExtractor,\n  CallbackType,\n  SpendInfo,\n} from '@rosen-bridge/abstract-extractor';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { DataSource } from '@rosen-bridge/extended-typeorm';\nimport {\n  BlockInfo,\n  ErgoNetworkType,\n  OutputBox,\n  Transaction,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport EventTriggerAction from '../actions/eventTriggerAction';\nimport EventTriggerEntity from '../entities/eventTriggerEntity';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { EventResult } from '../types';\nimport { JsonBI } from '../utils';\n\nclass EventTriggerExtractor extends AbstractErgoBoxExtractor<\n  ExtractedEventTrigger,\n  EventTriggerEntity\n> {\n  id: string;\n  protected readonly actions: EventTriggerAction;\n  private readonly eventTriggerErgoTree: string;\n  private readonly permitErgoTree: string;\n  private readonly fraudErgoTree: string;\n  private readonly RWT: string;\n\n  constructor(\n    id: string,\n    dataSource: DataSource,\n    type: ErgoNetworkType,\n    url: string,\n    address: string,\n    RWT: string,\n    permitAddress: string,\n    fraudAddress: string,\n    logger?: AbstractLogger,\n    initialize = true,\n  ) {\n    super({ type, url, address, active: initialize }, logger);\n    this.id = id;\n    this.eventTriggerErgoTree = wasm.Address.from_base58(address)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.permitErgoTree = wasm.Address.from_base58(permitAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.fraudErgoTree = wasm.Address.from_base58(fraudAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.RWT = RWT;\n    this.actions = new EventTriggerAction(\n      dataSource,\n      this.logger.child('EventTriggerAction'),\n    );\n  }\n\n  /**\n   * get Id for current extractor\n   */\n  getId = () => this.id;\n\n  /**\n   * check proper data format in the box\n   *  - box ergoTree\n   *  - RWT in first token place\n   *  - widListHash in R4\n   *  - event data in R5\n   *  - widCount in R7\n   * @param box\n   * @return true if the box has the required data and false otherwise\n   */\n  hasBoxData = (box: OutputBox): boolean => {\n    try {\n      if (\n        box.additionalRegisters &&\n        box.additionalRegisters.R4 &&\n        box.additionalRegisters.R5 &&\n        box.additionalRegisters.R7 &&\n        box.assets &&\n        box.assets.length > 0 &&\n        box.assets[0].tokenId === this.RWT &&\n        box.ergoTree === this.eventTriggerErgoTree\n      ) {\n        const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n        const R4Serialized = parsedBox\n          .register_value(wasm.NonMandatoryRegisterId.R4)!\n          .to_byte_array();\n        const R5Serialized = parsedBox\n          .register_value(wasm.NonMandatoryRegisterId.R5)!\n          .to_coll_coll_byte();\n        if (R4Serialized.length >= 1 && R5Serialized.length >= 12) return true;\n      }\n    } catch (e) {\n      this.logger.warn(\n        `Unexpected error occurred while checking the proper trigger data format for box ${box.boxId}: ${e}`,\n      );\n    }\n    return false;\n  };\n\n  /**\n   * extract box data to proper format (not including spending information)\n   * @param box\n   * @return extracted data in proper format\n   */\n  extractBoxData = (\n    box: OutputBox,\n  ): Omit<ExtractedEventTrigger, 'spendBlock' | 'spendHeight'> | undefined => {\n    try {\n      const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n      const R4Serialized = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R4)!\n        .to_byte_array();\n      const R5Serialized = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R5)!\n        .to_coll_coll_byte();\n\n      const WIDsCount = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R7)!\n        .to_i32();\n      const WIDsHash = Buffer.from(R4Serialized).toString('hex');\n      const sourceTxId = Buffer.from(R5Serialized[0]).toString();\n      const eventId = Buffer.from(blake2b(sourceTxId, undefined, 32)).toString(\n        'hex',\n      );\n      return {\n        eventId: eventId,\n        txId: box.transactionId,\n        identifier: box.boxId,\n        serialized: Buffer.from(parsedBox.sigma_serialize_bytes()).toString(\n          'base64',\n        ),\n        toChain: Buffer.from(R5Serialized[2]).toString(),\n        toAddress: Buffer.from(R5Serialized[4]).toString(),\n        networkFee: BigInt(\n          '0x' + Buffer.from(R5Serialized[7]).toString('hex'),\n        ).toString(10),\n        bridgeFee: BigInt(\n          '0x' + Buffer.from(R5Serialized[6]).toString('hex'),\n        ).toString(10),\n        amount: BigInt(\n          '0x' + Buffer.from(R5Serialized[5]).toString('hex'),\n        ).toString(10),\n        sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),\n        targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),\n        sourceTxId: sourceTxId,\n        fromChain: Buffer.from(R5Serialized[1]).toString(),\n        fromAddress: Buffer.from(R5Serialized[3]).toString(),\n        sourceBlockId: Buffer.from(R5Serialized[10]).toString(),\n        WIDsCount: WIDsCount,\n        WIDsHash: WIDsHash,\n        sourceChainHeight: Number(\n          BigInt('0x' + Buffer.from(R5Serialized[11]).toString('hex')).toString(\n            10,\n          ),\n        ),\n      };\n    } catch (e) {\n      this.logger.warn(\n        `Unexpected error occurred while extracting trigger data for box ${box.boxId}: ${e}`,\n      );\n      return undefined;\n    }\n  };\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param block\n   * @param txs\n   */\n  processTransactions = async (\n    txs: Array<Transaction>,\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    try {\n      const boxes: Array<ExtractedEventTrigger> = [];\n      const spendInfoArray: Array<SpendInfo> = [];\n      txs.forEach((transaction) => {\n        // extract event result\n        const { result, paymentTxId } = this.extractEventResult(transaction);\n        for (const output of transaction.outputs) {\n          // extract output box data\n          if (this.hasBoxData(output)) {\n            this.logger.debug(\n              `Trying to extract data from box ${output.boxId} at height ${block.height}`,\n            );\n            const data = this.extractBoxData(output);\n            if (data) {\n              this.logger.debug(\n                `Extracted data ${JsonBI.stringify(data)} from box ${\n                  output.boxId\n                }`,\n              );\n              boxes.push(data);\n            }\n          }\n        }\n        // process inputs\n        for (let index = 0; index < transaction.inputs.length; index++)\n          spendInfoArray.push({\n            txId: transaction.id,\n            boxId: transaction.inputs[index].boxId,\n            index: index,\n            extras: { result, paymentTxId },\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 at height ${block.height} for extractor ${this.id}`,\n          );\n          return false;\n        }\n        this.triggerCallbacks(CallbackType.Insert, boxes);\n      }\n      const spentData = await this.actions.spendBoxes(\n        spendInfoArray,\n        block,\n        this.id,\n      );\n      this.triggerCallbacks(CallbackType.Spend, spentData);\n    } catch (e) {\n      this.logger.error(\n        `Error in storing data in ${this.getId()} of the block ${\n          block.height\n        }: ${e}`,\n      );\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * extracts result and paymentTxId from a transaction\n   * returns 'unknown' as result when tx is neither fraud or successful\n   * @param transaction\n   * @returns\n   */\n  protected extractEventResult = (transaction: Transaction) => {\n    let result = EventResult.unknown;\n    let paymentTxId = '';\n    if (transaction.outputs[0].ergoTree === this.fraudErgoTree)\n      result = EventResult.fraud;\n    else if (transaction.outputs[0].ergoTree === this.permitErgoTree) {\n      result = EventResult.successful;\n      // find first non-watcher box with R4 value\n      for (const box of transaction.outputs) {\n        // if it's watcher box, skip it\n        if (box.ergoTree === this.permitErgoTree) continue;\n        const outputParsed = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n        try {\n          const R4Serialized = outputParsed\n            .register_value(wasm.NonMandatoryRegisterId.R4)\n            ?.to_byte_array();\n          if (R4Serialized !== undefined) {\n            let txId = Buffer.from(R4Serialized).toString();\n            // we assumed txId only includes these characters\n            if (!txId.match(/^[0-9a-zA-Z\\-_.]+$/)) {\n              // backward compatibility\n              txId = Buffer.from(R4Serialized).toString('hex');\n            }\n            paymentTxId = txId;\n            if (txId === '') {\n              paymentTxId = transaction.id;\n              this.logger.debug(\n                `successful event is spent. tx [${transaction.id}] is both payment and reward distribution tx`,\n              );\n            }\n            // paymentTxId is extracted. no need to process next boxes\n            break;\n          }\n        } catch {\n          continue;\n        }\n      }\n    }\n    return {\n      result,\n      paymentTxId,\n    };\n  };\n}\n\nexport default EventTriggerExtractor;\n"]}