@rosen-bridge/abstract-extractor 2.1.0 → 2.1.1

package/lib/ergo/network/NodeNetwork.ts

@@ -1,169 +0,0 @@
-import ergoNodeClientFactory, {
-  IndexedErgoBox,
-  IndexedErgoTransaction,
-} from '@rosen-clients/ergo-node';
-import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
-
-import { ErgoBox, ExtendedTransaction } from '../interfaces';
-import { AbstractNetwork } from './AbstractNetwork';
-
-export class NodeNetwork extends AbstractNetwork {
-  private api;
-
-  constructor(url: string) {
-    super();
-    this.api = ergoNodeClientFactory(url);
-  }
-
-  /**
-   * convert node api boxes to ErgoBox interface
-   * @param box
-   * @returns ErgoBox
-   */
-  private convertBox = async (box: IndexedErgoBox): Promise<ErgoBox> => {
-    const tx = await await this.api.getTxById(box.transactionId!);
-    const spendInfo = box.spentTransactionId
-      ? await this.getSpendingInfo(box.boxId!, box.spentTransactionId)
-      : undefined;
-    return {
-      transactionId: box.transactionId || '',
-      index: box.index || 0,
-      value: box.value || 0n,
-      ergoTree: box.ergoTree || '',
-      creationHeight: box.creationHeight || 0,
-      inclusionHeight: tx.inclusionHeight,
-      assets: box.assets || [],
-      additionalRegisters: box.additionalRegisters,
-      boxId: box.boxId || '',
-      blockId: tx.blockId,
-      spentBlockId: spendInfo?.hash,
-      spentHeight: spendInfo?.height,
-      spentTransactionId: box.spentTransactionId,
-      spentIndex: spendInfo?.spendIndex,
-    };
-  };
-
-  /**
-   * convert Node transaction to extractor transaction type
-   * @param tx
-   */
-  private convertTransaction = (
-    tx: IndexedErgoTransaction,
-  ): ExtendedTransaction => {
-    return {
-      id: tx.id || '',
-      inclusionHeight: tx.inclusionHeight,
-      blockId: tx.blockId,
-      outputs: tx.outputs.map((output) => ({
-        transactionId: output.transactionId || '',
-        index: output.index || 0,
-        value: output.value || 0n,
-        ergoTree: output.ergoTree || '',
-        creationHeight: output.creationHeight || 0,
-        assets: output.assets || [],
-        additionalRegisters: output.additionalRegisters,
-        boxId: output.boxId || '',
-      })),
-      // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156
-      inputs: tx.inputs.map((input) => ({ boxId: input.boxId! })) ?? [],
-      dataInputs: tx.dataInputs,
-    };
-  };
-
-  /**
-   * return spending information of a specified box by having spendTxId
-   * @param boxId
-   * @param spendTxId
-   */
-  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,
-    };
-  };
-
-  /**
-   * use node api to return related boxes by specified address
-   * @param address
-   * @param offset
-   * @param limit
-   * @returns related boxes
-   */
-  getBoxesByAddress = async (
-    address: string,
-    offset: number,
-    limit: number,
-  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {
-    const boxes = await this.api.getBoxesByAddressUnspent(address, {
-      offset: offset,
-      limit: limit,
-      sortDirection: 'desc',
-    });
-    if (!boxes)
-      throw new Error('Ergo node BoxesByAddress api expected to have items');
-    const ergoBoxes = await Promise.all(
-      boxes.map(async (box) => await this.convertBox(box)),
-    );
-    return { boxes: ergoBoxes, hasNextBatch: boxes.length > 0 };
-  };
-
-  /**
-   * use node api to return related boxes by specified token id
-   * @param tokenId
-   * @param offset
-   * @param limit
-   * @returns related boxes
-   */
-  getBoxesByTokenId = async (
-    tokenId: string,
-    offset: number,
-    limit: number,
-  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {
-    const boxes = await this.api.getBoxesByTokenId(tokenId, {
-      offset: offset,
-      limit: limit,
-    });
-    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.convertBox(box)),
-    );
-    return { boxes: ergoBoxes, hasNextBatch: boxes.items.length > 0 };
-  };
-
-  /**
-   * use node api to return related transactions of the specified address with limit offset
-   * @param tokenId
-   * @param offset
-   * @param limit
-   * @returns related transactions
-   */
-  getAddressTransactionsWithOffsetLimit = async (
-    address: string,
-    offset: number,
-    limit: number,
-  ): Promise<{ items: Array<ExtendedTransaction>; total: number }> => {
-    const txs = await this.api.getTxsByAddress(address, {
-      offset,
-      limit,
-    });
-    if (!txs.items)
-      throw new Error(
-        'Explorer AddressTransactions api expected to have items',
-      );
-    return {
-      items: txs.items.map((tx) => this.convertTransaction(tx)),
-      total: txs.total!,
-    };
-  };
-}

package/lib/ergo/utils.ts

@@ -1,15 +0,0 @@
-import { intersection } from 'lodash-es';
-import { OutputBox } from '@rosen-bridge/scanner-interfaces';
-
-/**
- * Check box to have specified tokens
- * @param box
- * @return true if box has the required token and false otherwise
- */
-export const boxHasToken = (box: OutputBox, tokenIds: string[]) => {
-  if (!box.assets) return false;
-  const boxTokens = box.assets.map((token) => token.tokenId);
-  const requiredTokens = intersection(tokenIds, boxTokens);
-  if (requiredTokens.length == tokenIds.length) return true;
-  return false;
-};

package/lib/index.ts

@@ -1,3 +0,0 @@
-export * from './ergo';
-export * from './constants';
-export * from './abstractExtractor';

package/tests/AbstractErgoExtractor.mock.ts

@@ -1,33 +0,0 @@
-import { V1 } from '@rosen-clients/ergo-explorer';
-import { BlockInfo, OutputBox } from '@rosen-bridge/scanner-interfaces';
-
-import {
-  AbstractErgoExtractor,
-  AbstractBoxData,
-  AbstractErgoExtractorAction,
-  AbstractErgoExtractorEntity,
-} from '../lib';
-
-export class MockedErgoExtractor extends AbstractErgoExtractor<
-  AbstractBoxData,
-  AbstractErgoExtractorEntity
-> {
-  actions: AbstractErgoExtractorAction<
-    AbstractBoxData,
-    AbstractErgoExtractorEntity
-  >;
-
-  getId = () => 'Test';
-
-  initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;
-
-  hasData = (
-    box: V1.OutputInfo | OutputBox, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ) => false;
-
-  extractBoxData = (
-    box: V1.OutputInfo | OutputBox, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ): AbstractBoxData | undefined => {
-    return undefined;
-  };
-}

package/tests/AbstractErgoExtractor.spec.ts

@@ -1,284 +0,0 @@
-import { V1 } from '@rosen-clients/ergo-explorer';
-import { OutputBox } from '@rosen-bridge/scanner-interfaces';
-
-import {
-  AbstractBoxData,
-  AbstractErgoExtractorAction,
-  CallbackType,
-  AbstractErgoExtractorEntity,
-} from '../lib';
-import { block, extractedData, tx } from './testData';
-import { MockedErgoExtractor } from './AbstractErgoExtractor.mock';
-
-describe('AbstractErgoExtractor', () => {
-  describe('processTransactions', () => {
-    /**
-     * @target processTransactions should initialize extractor with specified id and insert status into db
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock `hasData` to return true for one box
-     * - spy `extractBoxData` and `storeBoxes`
-     * - run test (call `processTransactions`)
-     * @expected
-     * - to call `extractBoxData` for the specific box and all input extensions
-     * - to insert the extracted box to database
-     * - to return true when total procedure is successful
-     * - to trigger `INSERT` callbacks with correct data
-     */
-    it('should process boxes with data and insert data into database', async () => {
-      const extractor = new MockedErgoExtractor();
-      const triggerCallbacks = vitest.fn();
-      extractor['triggerCallbacks'] = triggerCallbacks;
-      extractor.hasData = (box: V1.OutputInfo | OutputBox) => {
-        if (box.boxId == tx.outputs[0].boxId) return true;
-        return false;
-      };
-      const extractSpy = vitest.fn().mockReturnValue(extractedData);
-      extractor.extractBoxData = extractSpy;
-      const storeSpy = vitest.fn().mockResolvedValue(true);
-      const spendSpy = vitest.fn().mockResolvedValue([]);
-      extractor['actions'] = {
-        storeBoxes: storeSpy,
-        spendBoxes: spendSpy,
-      } as unknown as AbstractErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const result = await extractor.processTransactions([tx], block);
-
-      expect(extractSpy).toBeCalledTimes(1);
-      expect(extractSpy).toBeCalledWith(
-        tx.outputs[0],
-        [tx.inputs[0].extension, {}],
-        {},
-      );
-      expect(storeSpy).toBeCalledWith([extractedData], block, 'Test');
-      expect(result).toEqual(true);
-      expect(triggerCallbacks).toBeCalledWith(CallbackType.Insert, [
-        extractedData,
-      ]);
-    });
-
-    /**
-     * @target processTransactions should extract spending information of all input boxes
-     * @dependencies
-     * @scenario
-     * - mock extractor (hasData returns false as default)
-     * - spy `extractBoxData`, `storeBoxes` and `spendBoxes`
-     * - run test (call `processTransactions`)
-     * @expected
-     * - not to call `extractBoxData` and `storeBoxes` when there is not any box with data
-     * - to extractor spend info of input boxes and call `spendBoxes`
-     * - to return true when total procedure is successful
-     * - to trigger `SPEND` callbacks with correct data
-     */
-    it('should extract spending information of all input boxes', async () => {
-      const extractor = new MockedErgoExtractor();
-      const triggerCallbacks = vitest.fn();
-      extractor['triggerCallbacks'] = triggerCallbacks;
-      const extractSpy = vitest.fn();
-      extractor.extractBoxData = extractSpy;
-      const storeSpy = vitest.fn().mockResolvedValue(true);
-      const spendSpy = vitest
-        .fn()
-        .mockResolvedValue([
-          { boxId: tx.inputs[0].boxId },
-          { boxId: tx.inputs[1].boxId },
-        ]);
-      extractor['actions'] = {
-        storeBoxes: storeSpy,
-        spendBoxes: spendSpy,
-      } as unknown as AbstractErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const result = await extractor.processTransactions([tx], block);
-
-      expect(extractSpy).not.toBeCalled();
-      expect(storeSpy).not.toBeCalled();
-      expect(spendSpy).toBeCalledWith(
-        [
-          { boxId: tx.inputs[0].boxId, txId: tx.id, index: 1 },
-          { boxId: tx.inputs[1].boxId, txId: tx.id, index: 2 },
-        ],
-        block,
-        'Test',
-      );
-      expect(result).toEqual(true);
-      expect(triggerCallbacks).toBeCalledWith(CallbackType.Spend, [
-        { boxId: tx.inputs[0].boxId },
-        { boxId: tx.inputs[1].boxId },
-      ]);
-    });
-
-    /**
-     * @target processTransactions should return false if data insertion fails
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock `hasData` to return true for one box
-     * - spy `extractBoxData` and `storeBoxes`
-     * - run test (call `processTransactions`)
-     * @expected
-     * - to return false when `insertBoxes` returns false
-     * - not to call `spendBoxes` if data insertion fails
-     */
-    it('should return false if data insertion fails', async () => {
-      const extractor = new MockedErgoExtractor();
-      extractor.hasData = (box: V1.OutputInfo | OutputBox) => {
-        if (box.boxId == tx.outputs[0].boxId) return true;
-        return false;
-      };
-      const extractSpy = vitest.fn().mockReturnValue(extractedData);
-      extractor.extractBoxData = extractSpy;
-      const storeSpy = vitest.fn().mockResolvedValue(false);
-      const spendSpy = vitest.fn();
-      extractor['actions'] = {
-        storeBoxes: storeSpy,
-        spendBoxes: spendSpy,
-      } as unknown as AbstractErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const result = await extractor.processTransactions([tx], block);
-
-      expect(result).toEqual(false);
-      expect(spendSpy).not.toBeCalled();
-    });
-  });
-
-  describe('forkBlock', () => {
-    /**
-     * @target forkBlock should remove all data extracted from the specified block
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - spy `deleteBlockBoxes`
-     * - run test (call `forkBlock`)
-     * @expected
-     * - to call `deleteBlockBoxes` for the specific box
-     * - to trigger `DELETE` callbacks for the deleted box
-     * - to trigger `UPDATE` callbacks for the spent box
-     */
-    it('should remove all data extracted from the specified block', async () => {
-      const extractor = new MockedErgoExtractor();
-      const removeSpy = vitest.fn().mockResolvedValue({
-        deletedData: [{ boxId: 'box1' }],
-        updatedData: [{ boxId: 'box2' }],
-      });
-      extractor['actions'] = {
-        deleteBlockBoxes: removeSpy,
-      } as unknown as AbstractErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const triggerCallbackSpy = vitest.fn().mockClear();
-      extractor['triggerCallbacks'] = triggerCallbackSpy;
-      await extractor.forkBlock(block.hash);
-      expect(removeSpy).toBeCalledWith(block.hash, 'Test');
-      expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Delete, [
-        { boxId: 'box1' },
-      ]);
-      expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Update, [
-        { boxId: 'box2' },
-      ]);
-    });
-  });
-
-  describe('hook', () => {
-    /**
-     * @target hook should hook a new callback on insert with the new id
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock a callback for insert
-     * - run test (call `hook`)
-     * @expected
-     * - hook the callback with the specified id
-     * - return true
-     */
-    it('should hook a new callback on insert with the new id', async () => {
-      const extractor = new MockedErgoExtractor();
-      const insertCallback = vitest.fn();
-      const id = await extractor.hook(CallbackType.Insert, insertCallback);
-      expect(extractor['callbacks'][CallbackType.Insert]).toEqual(
-        new Map().set(id, insertCallback),
-      );
-    });
-  });
-
-  describe('unhook', () => {
-    /**
-     * @target unhook should unhook the callback on insert with the specified id
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock a callback for insert
-     * - hook the callback
-     * - run test (call `unhook`)
-     * @expected
-     * - unhook the callback with the specified id
-     * - return true
-     */
-    it('should unhook the callback on insert with the specified id', async () => {
-      const extractor = new MockedErgoExtractor();
-      const insertCallback = vitest.fn();
-      const id = await extractor.hook(CallbackType.Insert, insertCallback);
-      const result = await extractor.unhook(CallbackType.Insert, id);
-      expect(result).toBeTruthy();
-      expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(
-        undefined,
-      );
-    });
-
-    /**
-     * @target unhook should not unhook callbacks with the same id on other types
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock two callbacks for insert
-     * - hook the first callback
-     * - run test (call `unhook` with the same id for second callback)
-     * @expected
-     * - not to change hooked callbacks when the callback with the id
-     * doesn't exists on the specified type
-     * - return false
-     */
-    it('should not unhook callbacks with the same id on other types', async () => {
-      const extractor = new MockedErgoExtractor();
-      const insertCallback = vitest.fn();
-      const id = await extractor.hook(CallbackType.Insert, insertCallback);
-      const result = await extractor.unhook(CallbackType.Update, id);
-      expect(result).toBeFalsy();
-      expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(
-        insertCallback,
-      );
-      expect(extractor['callbacks'][CallbackType.Update].get(id)).toEqual(
-        undefined,
-      );
-    });
-  });
-
-  describe('triggerCallbacks', () => {
-    /**
-     * @target triggerCallbacks should trigger all callbacks hooked on a type
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - mock a callback for insert
-     * - hook the callback
-     * - run test (call `triggerCallbacks` for insert type)
-     * @expected
-     * - trigger all callbacks with the specified id
-     */
-    it('should trigger all callbacks hooked on a type', async () => {
-      const extractor = new MockedErgoExtractor();
-      const insertCallback = vitest.fn();
-      await extractor.hook(CallbackType.Insert, insertCallback);
-      const insertedData = [{ boxId: 'boxId', serialized: 'serialized' }];
-      await extractor['triggerCallbacks'](CallbackType.Insert, insertedData);
-      expect(insertCallback).toBeCalledWith(insertedData);
-    });
-  });
-});

package/tests/AbstractErgoExtractorAction.mock.ts

@@ -1,45 +0,0 @@
-import { DataSource } from '@rosen-bridge/extended-typeorm';
-import { pick } from 'lodash-es';
-import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
-
-import {
-  AbstractErgoExtractorAction,
-  AbstractErgoExtractorEntity,
-  AbstractBoxData,
-} from '../lib';
-import { TestEntity } from './testUtils';
-
-export class TestErgoExtractorAction extends AbstractErgoExtractorAction<
-  AbstractBoxData,
-  AbstractErgoExtractorEntity
-> {
-  constructor(dataSource: DataSource) {
-    super(dataSource, TestEntity);
-  }
-
-  /**
-   * create the test database entity from data and block information
-   */
-  createEntity = (
-    boxes: AbstractBoxData[],
-    block: BlockInfo,
-    extractor: string,
-  ): Omit<AbstractErgoExtractorEntity, 'id'>[] => {
-    return boxes.map((box) => ({
-      boxId: box.boxId,
-      block: block.hash,
-      height: block.height,
-      serialized: box.serialized,
-      extractor: extractor,
-    }));
-  };
-
-  /**
-   * convert the database entity back to raw data
-   */
-  convertEntityToData = (
-    entities: AbstractErgoExtractorEntity[],
-  ): AbstractBoxData[] => {
-    return entities.map((data) => pick(data, ['boxId', 'serialized']));
-  };
-}