@rosen-bridge/abstract-extractor 0.1.4 → 0.2.0

package/lib/ergo/AbstractErgoExtractor.ts

@@ -82,11 +82,10 @@ export abstract class AbstractErgoExtractor<
           spentInfos.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });
           boxIndex += 1;
         }
-
-        if (boxes.length > 0)
-          await this.actions.insertBoxes(boxes, this.getId());
-        await this.actions.spendBoxes(spentInfos, block, this.getId());
       }
+
+      if (boxes.length > 0) await this.actions.insertBoxes(boxes, this.getId());
+      await this.actions.spendBoxes(spentInfos, block, this.getId());
     } catch (e) {
       this.logger.error(
         `Error in storing data in ${this.getId()} of the block ${block}: ${e}`

package/lib/ergo/initializable/AbstractInitializable.ts

@@ -34,13 +34,6 @@ export abstract class AbstractInitializableErgoExtractor<
     limit: number
   ) => Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }>;
 
-  /**
-   * return block information of specified tx
-   * @param txId
-   * @return block info
-   */
-  abstract getTxBlock: (txId: string) => Promise<BlockInfo>;
-
   /**
    * return all related data below the initial height (including the init height)
    * @param initialHeight
@@ -75,6 +68,8 @@ export abstract class AbstractInitializableErgoExtractor<
         ...data,
         spendBlock: spent ? box.spentBlockId : undefined,
         spendHeight: spent ? box.spentHeight : undefined,
+        spendTxId: spent ? box.spentTransactionId : undefined,
+        spendIndex: spent ? box.spentIndex : undefined,
       } as ExtractedData;
       this.logger.debug(
         `Extracted data ${JsonBigInt.stringify(extractedData)} from box ${
@@ -93,7 +88,6 @@ export abstract class AbstractInitializableErgoExtractor<
    * @param initialBlock
    */
   initializeBoxes = async (initialBlock: BlockInfo) => {
-    const fetched = new Set<string>();
     let trial = 1;
     if (this.initialize) {
       this.logger.debug(
@@ -110,18 +104,13 @@ export abstract class AbstractInitializableErgoExtractor<
             offset,
             API_LIMIT
           );
-          const boxes = data.extractedBoxes.filter((item) => {
-            if (fetched.has(item.boxId)) return false;
-            fetched.add(item.boxId);
-            return true;
-          });
           this.logger.info(
             `Inserting ${
-              boxes.length
+              data.extractedBoxes.length
             } new extracted data in ${this.getId()} initialization`
           );
           const insertSuccess = await this.actions.insertBoxes(
-            boxes,
+            data.extractedBoxes,
             this.getId()
           );
           if (!insertSuccess) throw new Error('Could not store extracted data');

package/lib/ergo/initializable/InitializableByAddress.ts

@@ -2,7 +2,6 @@ import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 
 import { ErgoExtractedData, ErgoNetworkType, ErgoBox } from '../interfaces';
 import { AbstractInitializableErgoExtractor } from './AbstractInitializable';
-import { BlockInfo } from '../../interfaces';
 import { ExplorerNetwork } from '../network/ExplorerNetwork';
 import { NodeNetwork } from '../network/NodeNetwork';
 import { AbstractNetwork } from '../network/AbstractNetwork';
@@ -41,13 +40,4 @@ export abstract class AbstractInitializableByAddressErgoExtractor<
   ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {
     return this.network.getBoxesByAddress(this.address, offset, limit);
   };
-
-  /**
-   * return block information from the specified network source
-   * @param txId
-   * @return block info
-   */
-  getTxBlock = (txId: string): Promise<BlockInfo> => {
-    return this.network.getTxBlock(txId);
-  };
 }

package/lib/ergo/initializable/InitializableByToken.ts

@@ -2,7 +2,6 @@ import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 
 import { ErgoExtractedData, ErgoNetworkType, ErgoBox } from '../interfaces';
 import { AbstractInitializableErgoExtractor } from './AbstractInitializable';
-import { BlockInfo } from '../../interfaces';
 import { ExplorerNetwork } from '../network/ExplorerNetwork';
 import { NodeNetwork } from '../network/NodeNetwork';
 import { AbstractNetwork } from '../network/AbstractNetwork';
@@ -41,13 +40,4 @@ export abstract class AbstractInitializableByTokenErgoExtractor<
   ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {
     return this.network.getBoxesByTokenId(this.tokenId, offset, limit);
   };
-
-  /**
-   * return block information from the specified network source
-   * @param txId
-   * @return block info
-   */
-  getTxBlock = (txId: string): Promise<BlockInfo> => {
-    return this.network.getTxBlock(txId);
-  };
 }

package/lib/ergo/interfaces.ts

@@ -41,6 +41,8 @@ export interface ErgoBox extends OutputBox {
   inclusionHeight: number;
   spentBlockId?: string;
   spentHeight?: number;
+  spentTransactionId?: string;
+  spentIndex?: number;
 }
 
 export type Transaction = {
@@ -63,4 +65,6 @@ export interface ErgoExtractedData {
   blockId: string;
   spendBlock?: string;
   spendHeight?: number;
+  spendTxId?: string;
+  spendIndex?: number;
 }

package/lib/ergo/network/AbstractNetwork.ts

@@ -1,12 +1,6 @@
-import { BlockInfo } from '../../interfaces';
 import { ErgoBox } from '../interfaces';
-export abstract class AbstractNetwork {
-  /**
-   * return block information of specified tx
-   * @param txId
-   */
-  abstract getTxBlock: (txId: string) => Promise<BlockInfo>;
 
+export abstract class AbstractNetwork {
   /**
    * return related boxes by specified address with limit offset
    * @param address

package/lib/ergo/network/ExplorerNetwork.ts

@@ -4,6 +4,7 @@ import { BlockInfo } from '../../interfaces';
 import { ErgoBox } from '../interfaces';
 import { AbstractNetwork } from './AbstractNetwork';
 import { V1 } from '@rosen-clients/ergo-explorer';
+import { mapValues, pick } from 'lodash-es';
 
 export class ExplorerNetwork extends AbstractNetwork {
   private api;
@@ -14,14 +15,24 @@ export class ExplorerNetwork extends AbstractNetwork {
   }
 
   /**
-   * return block information of specified tx
-   * @param txId
+   * return spending information of a specified box by having spendTxId
+   * @param boxId
+   * @param spendTxId
    */
-  getTxBlock = async (txId: string): Promise<BlockInfo> => {
-    const tx = await this.api.v1.getApiV1TransactionsP1(txId);
+  getSpendingInfo = async (
+    boxId: string,
+    spendTxId: string
+  ): Promise<BlockInfo & { spendIndex: number }> => {
+    const tx = await this.api.v1.getApiV1TransactionsP1(spendTxId);
+    const spendIndex = tx.inputs?.findIndex((box) => box.boxId === boxId);
+    if (spendIndex == undefined)
+      throw Error(
+        `Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`
+      );
     return {
       hash: tx.blockId,
       height: tx.inclusionHeight,
+      spendIndex,
     };
   };
 
@@ -32,7 +43,7 @@ export class ExplorerNetwork extends AbstractNetwork {
    */
   convertBox = async (box: V1.OutputInfo): Promise<ErgoBox> => {
     const spendInfo = box.spentTransactionId
-      ? await this.getTxBlock(box.spentTransactionId)
+      ? await this.getSpendingInfo(box.boxId, box.spentTransactionId)
       : undefined;
     return {
       blockId: box.blockId,
@@ -43,10 +54,15 @@ export class ExplorerNetwork extends AbstractNetwork {
       index: box.index,
       transactionId: box.transactionId,
       value: box.value,
-      additionalRegisters: box.additionalRegisters,
-      assets: box.assets,
+      additionalRegisters: mapValues(
+        box.additionalRegisters,
+        'serializedValue'
+      ),
+      assets: box.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])),
       spentHeight: spendInfo?.height,
       spentBlockId: spendInfo?.hash,
+      spentTransactionId: box.spentTransactionId,
+      spentIndex: spendInfo?.spendIndex,
     };
   };
 

package/lib/ergo/network/NodeNetwork.ts

@@ -19,10 +19,10 @@ export class NodeNetwork extends AbstractNetwork {
    * @param box
    * @returns ErgoBox
    */
-  convertToErgoBox = async (box: IndexedErgoBox): Promise<ErgoBox> => {
-    const tx = await this.getTxBlock(box.transactionId!);
+  convertBox = async (box: IndexedErgoBox): Promise<ErgoBox> => {
+    const tx = await await this.api.getTxById(box.transactionId!);
     const spendInfo = box.spentTransactionId
-      ? await this.getTxBlock(box.spentTransactionId)
+      ? await this.getSpendingInfo(box.boxId!, box.spentTransactionId)
       : undefined;
     return {
       transactionId: box.transactionId || '',
@@ -30,25 +30,37 @@ export class NodeNetwork extends AbstractNetwork {
       value: box.value || 0n,
       ergoTree: box.ergoTree || '',
       creationHeight: box.creationHeight || 0,
-      inclusionHeight: tx.height,
+      inclusionHeight: tx.inclusionHeight,
       assets: box.assets || [],
       additionalRegisters: box.additionalRegisters,
       boxId: box.boxId || '',
-      blockId: tx.hash,
-      spentBlockId: spendInfo?.hash ?? undefined,
-      spentHeight: spendInfo?.height ?? undefined,
+      blockId: tx.blockId,
+      spentBlockId: spendInfo?.hash,
+      spentHeight: spendInfo?.height,
+      spentTransactionId: box.spentTransactionId,
+      spentIndex: spendInfo?.spendIndex,
     };
   };
 
   /**
-   * return block information of specified tx
-   * @param txId
+   * return spending information of a specified box by having spendTxId
+   * @param boxId
+   * @param spendTxId
    */
-  getTxBlock = async (txId: string): Promise<BlockInfo> => {
-    const tx = await this.api.getTxById(txId);
+  getSpendingInfo = async (
+    boxId: string,
+    spendTxId: string
+  ): Promise<BlockInfo & { spendIndex: number }> => {
+    const tx = await this.api.getTxById(spendTxId);
+    const spendIndex = tx.inputs?.findIndex((box) => box.boxId == boxId);
+    if (spendIndex == undefined)
+      throw Error(
+        `Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`
+      );
     return {
       hash: tx.blockId,
       height: tx.inclusionHeight,
+      spendIndex,
     };
   };
 
@@ -72,7 +84,7 @@ export class NodeNetwork extends AbstractNetwork {
     if (!boxes)
       throw new Error('Ergo node BoxesByAddress api expected to have items');
     const ergoBoxes = await Promise.all(
-      boxes.map(async (box) => await this.convertToErgoBox(box))
+      boxes.map(async (box) => await this.convertBox(box))
     );
     return { boxes: ergoBoxes, hasNextBatch: boxes.length > 0 };
   };
@@ -96,7 +108,7 @@ export class NodeNetwork extends AbstractNetwork {
     if (!boxes.items)
       throw new Error('Ergo node BoxesByTokenId api expected to have items');
     const ergoBoxes = await Promise.all(
-      boxes.items.map(async (box) => await this.convertToErgoBox(box))
+      boxes.items.map(async (box) => await this.convertBox(box))
     );
     return { boxes: ergoBoxes, hasNextBatch: boxes.items.length > 0 };
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/abstract-extractor",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Rosen Bridge extractor interfaces to work with scanner",
   "repository": "",
   "license": "GPL-3.0",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@rosen-bridge/abstract-logger": "^1.0.0",
-    "@rosen-clients/ergo-explorer": "^1.1.1",
+    "@rosen-clients/ergo-explorer": "^1.1.2",
     "@rosen-clients/ergo-node": "^1.1.1",
     "lodash-es": "^4.17.21"
   }

package/tests/initializable/AbstractInitializable.spec.ts

@@ -111,6 +111,9 @@ describe('AbstractInitializableErgoExtractorAction', () => {
             spendBlock:
               '9239ebca7b3b10701895e491a2213da4e07a37abc413d05434a5fab04993a19d',
             spendHeight: 1252680,
+            spendTxId:
+              'b08fa920a6907d0e76eb0ad754439f1a26fa112b39f4de489620e4e6241930b7',
+            spendIndex: 1,
           },
         ],
         hasNextBatch: true,

package/tests/initializable/testData.ts

@@ -51,6 +51,7 @@ export const ergoBoxes = [
       '9239ebca7b3b10701895e491a2213da4e07a37abc413d05434a5fab04993a19d',
     spentTransactionId:
       'b08fa920a6907d0e76eb0ad754439f1a26fa112b39f4de489620e4e6241930b7',
+    spentIndex: 1,
   },
 ];
 

package/tests/network/ExplorerNetwork.spec.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it, vitest } from 'vitest';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+
+import { ExplorerNetwork } from '../../lib';
+import { convertedBox, explorerBox, explorerTxInfo } from './testData';
+
+vitest.mock('@rosen-clients/ergo-explorer');
+
+describe('ExplorerNetwork', () => {
+  describe('convertBox', () => {
+    /**
+     * @target covertBox should properly convert explorer api box to ergo box
+     * @dependencies
+     * @scenario
+     * - mock getApiV1TransactionsP1 to return spending transaction
+     * - run test (call `covertBox`)
+     * @expected
+     * - to convert box properly
+     */
+    it('should properly convert explorer api box to ergo box', async () => {
+      vitest.mocked(ergoExplorerClientFactory).mockReturnValue({
+        v1: {
+          getApiV1TransactionsP1: async () => explorerTxInfo,
+        },
+      } as unknown as ReturnType<typeof ergoExplorerClientFactory>);
+      const explorerNetwork = new ExplorerNetwork('explorer_url');
+      const ergoBox = await explorerNetwork.convertBox(explorerBox);
+      expect(ergoBox).toEqual(convertedBox);
+    });
+  });
+});

package/tests/network/NodeNetwork.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vitest } from 'vitest';
+import ergoNodeClientFactory from '@rosen-clients/ergo-node';
+
+import { NodeNetwork } from '../../lib';
+import {
+  convertedBox,
+  nodeBox,
+  nodeSpendingTxInfo,
+  nodeCreationTxInfo,
+} from './testData';
+
+vitest.mock('@rosen-clients/ergo-node');
+
+describe('NodeNetwork', () => {
+  describe('convertBox', () => {
+    /**
+     * @target covertBox should properly convert node api box to ergo box
+     * @dependencies
+     * @scenario
+     * - mock getTxById to return creation and spending transaction
+     * - run test (call `covertBox`)
+     * @expected
+     * - to convert box properly
+     */
+    it('should properly convert node api box to ergo box', async () => {
+      vitest.mocked(ergoNodeClientFactory).mockReturnValue({
+        getTxById: async (txId: string) => {
+          if (txId == nodeSpendingTxInfo.id) return nodeSpendingTxInfo;
+          else return nodeCreationTxInfo;
+        },
+      } as unknown as ReturnType<typeof ergoNodeClientFactory>);
+      const nodeNetwork = new NodeNetwork('node_url');
+      const ergoBox = await nodeNetwork.convertBox(nodeBox);
+      expect(ergoBox).toEqual(convertedBox);
+    });
+  });
+});