@rosen-bridge/tx-pot 0.1.0 → 1.0.0

package/lib/transaction/TxPot.ts

@@ -1,6 +1,6 @@
 import { DataSource, Repository } from 'typeorm';
 import { TransactionEntity } from '../db/entities/TransactionEntity';
-import { AbstractLogger, DummyLogger } from '@rosen-bridge/logger-interface';
+import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';
 import {
   CallbackFunction,
   SigningStatus,
@@ -16,10 +16,17 @@ export class TxPot {
   protected static instance: TxPot;
   protected readonly txRepository: Repository<TransactionEntity>;
   protected chains = new Map<string, AbstractPotChainManager>();
-  protected validators = new Map<string, Map<string, ValidatorFunction>>();
+  protected validators = new Map<
+    string,
+    Map<string, Map<string, ValidatorFunction>>
+  >();
   protected txTypeCallbacks = new Map<
     string,
-    Map<TransactionStatus, CallbackFunction>
+    Map<TransactionStatus, Map<string, CallbackFunction>>
+  >();
+  protected submissionAllowance = new Map<
+    string,
+    Map<string, ValidatorFunction>
   >();
   protected logger: AbstractLogger;
 
@@ -71,22 +78,107 @@ export class TxPot {
    * registers a validator function
    * @param chain
    * @param txType
+   * @param id
    * @param validator
    */
   registerValidator = (
     chain: string,
     txType: string,
+    id: string,
     validator: ValidatorFunction
   ): void => {
     let chainValidators = this.validators.get(chain);
     if (!chainValidators) {
-      chainValidators = new Map<string, ValidatorFunction>();
+      chainValidators = new Map<string, Map<string, ValidatorFunction>>();
       this.validators.set(chain, chainValidators);
     }
 
-    chainValidators.set(txType, validator);
-    this.logger.debug(
-      `A tx validator function is registered for chain [${chain}] and type [${txType}]`
+    let typeValidators = chainValidators.get(txType);
+    if (!typeValidators) {
+      typeValidators = new Map<string, ValidatorFunction>();
+      chainValidators.set(txType, typeValidators);
+    }
+    const currentValidator = typeValidators.get(id);
+    typeValidators.set(id, validator);
+    if (currentValidator) {
+      this.logger.debug(
+        `The tx validator function for chain [${chain}], type [${txType}] and id [${id}] is replaced`
+      );
+    } else {
+      this.logger.info(
+        `New tx validator function is registered for chain [${chain}] and type [${txType}] by id [${id}]`
+      );
+    }
+  };
+
+  /**
+   * removes a validator function
+   * @param chain
+   * @param txType
+   * @param id
+   */
+  unregisterValidator = (chain: string, txType: string, id: string): void => {
+    const validators = this.validators.get(chain)?.get(txType);
+    if (!validators) {
+      this.logger.debug(
+        `No tx validator function is set for chain [${chain}], type [${txType}] and id [${id}]`
+      );
+      return;
+    }
+
+    validators.delete(id);
+    this.logger.info(
+      `Removed tx validator function for chain [${chain}], type [${txType}] and id [${id}]`
+    );
+  };
+
+  /**
+   * registers a submit validator function
+   * @param chain
+   * @param id
+   * @param validator
+   */
+  registerSubmitValidator = (
+    chain: string,
+    id: string,
+    validator: ValidatorFunction
+  ): void => {
+    let chainAllowance = this.submissionAllowance.get(chain);
+    if (!chainAllowance) {
+      chainAllowance = new Map<string, ValidatorFunction>();
+      this.submissionAllowance.set(chain, chainAllowance);
+    }
+
+    const currentValidator = chainAllowance.get(id);
+    chainAllowance.set(id, validator);
+    if (currentValidator) {
+      this.logger.debug(
+        `The tx submit validator function for chain [${chain}] and id [${id}] is replaced`
+      );
+    } else {
+      this.logger.info(
+        `New tx submit validator function is registered for chain [${chain}] by id [${id}]`
+      );
+    }
+  };
+
+  /**
+   * removes a submit validator function
+   * @param chain
+   * @param id
+   */
+  unregisterSubmitValidator = (chain: string, id: string): void => {
+    const chainAllowance = this.submissionAllowance.get(chain);
+    if (!chainAllowance) {
+      this.logger.debug(
+        `No tx submit validator function is set for chain [${chain}] and id [${id}]`
+      );
+      return;
+    }
+
+    chainAllowance.delete(id);
+    this.logger.info(
+      `Removed tx submit validator function for chain [${chain}] and id [${id}]`
     );
   };
 
@@ -96,22 +188,65 @@ export class TxPot {
    *  of given type changes to given status
    * @param txType
    * @param status
+   * @param id
    * @param callback
    */
   registerCallback = (
     txType: string,
     status: TransactionStatus,
+    id: string,
     callback: CallbackFunction
   ): void => {
     let typeCallbacks = this.txTypeCallbacks.get(txType);
     if (!typeCallbacks) {
-      typeCallbacks = new Map<TransactionStatus, CallbackFunction>();
+      typeCallbacks = new Map<
+        TransactionStatus,
+        Map<string, CallbackFunction>
+      >();
       this.txTypeCallbacks.set(txType, typeCallbacks);
     }
 
-    typeCallbacks.set(status, callback);
-    this.logger.debug(
-      `A tx status callback function is registered for type [${txType}] and status [${status}]`
+    let statusCallbacks = typeCallbacks.get(status);
+    if (!statusCallbacks) {
+      statusCallbacks = new Map<string, CallbackFunction>();
+      typeCallbacks.set(status, statusCallbacks);
+    }
+
+    const currentCallback = statusCallbacks.get(id);
+    statusCallbacks.set(id, callback);
+    if (currentCallback) {
+      this.logger.debug(
+        `The tx status callback function for type [${txType}] and status [${status}] and id [${id}] is replaced`
+      );
+    } else {
+      this.logger.info(
+        `New tx status callback function is registered for type [${txType}] and status [${status}] by id [${id}]`
+      );
+    }
+  };
+
+  /**
+   * removes a callback function
+   * @param txType
+   * @param status
+   * @param id
+   */
+  unregisterCallback = (
+    txType: string,
+    status: TransactionStatus,
+    id: string
+  ): void => {
+    const callbacks = this.txTypeCallbacks.get(txType)?.get(status);
+    if (!callbacks) {
+      this.logger.debug(
+        `No tx status callback function is set for type [${txType}] and status [${status}] and id [${id}]`
+      );
+      return;
+    }
+
+    callbacks.delete(id);
+    this.logger.info(
+      `Removed tx status callback function for type [${txType}] and status [${status}] and id [${id}]`
     );
   };
 
@@ -162,18 +297,52 @@ export class TxPot {
    * @param tx
    */
   protected validateTx = async (tx: TransactionEntity): Promise<boolean> => {
-    const validator = this.validators.get(tx.chain)?.get(tx.txType);
-    if (validator === undefined) {
+    const validators = this.validators.get(tx.chain)?.get(tx.txType);
+    if (validators === undefined) {
       // tx is valid since no validator is found
       this.logger.debug(
         `No validator function is found for chain [${tx.chain}] and type [${tx.txType}]`
       );
       return true;
     }
-    if (await validator(tx)) return true;
+    for (const idValidatorPair of validators) {
+      if ((await idValidatorPair[1](tx)) === false) {
+        this.logger.debug(
+          `tx [${tx.txId}] is recognized as invalid by validator [${idValidatorPair[0]}]`
+        );
+        await this.setTransactionAsInvalid(tx);
+        return false;
+      }
+    }
+    return true;
+  };
 
-    await this.setTransactionAsInvalid(tx);
-    return false;
+  /**
+   * checks a transaction for submission
+   * returns true if no validator functions is set or all validators allow tx to submit
+   * otherwise returns false
+   * @param tx
+   */
+  protected isSubmitAllowed = async (
+    tx: TransactionEntity
+  ): Promise<boolean> => {
+    const validators = this.submissionAllowance.get(tx.chain);
+    if (validators === undefined) {
+      // tx is allowed for submission since no validator is found
+      this.logger.debug(
+        `No submit validator function is found for chain [${tx.chain}]`
+      );
+      return true;
+    }
+    for (const idValidatorPair of validators) {
+      if ((await idValidatorPair[1](tx)) === false) {
+        this.logger.debug(
+          `tx [${tx.txId}] is not allowed for submission by submit validator [${idValidatorPair[0]}]`
+        );
+        return false;
+      }
+    }
+    return true;
   };
 
   /**
@@ -195,15 +364,17 @@ export class TxPot {
         lastStatusUpdate: this.currentTime(),
       }
     );
-    const callback = this.txTypeCallbacks.get(tx.txType)?.get(status);
-    if (callback)
-      callback(tx, status).catch((e) => {
-        this.logger.debug(
-          `An error occurred while handling tx [${tx.txId}] status change: ${e}`
-        );
-        if (e instanceof Error && e.stack) this.logger.debug(e.stack);
-      });
-    else
+    const callbacks = this.txTypeCallbacks.get(tx.txType)?.get(status);
+    if (callbacks) {
+      for (const idCallbackPair of callbacks) {
+        idCallbackPair[1](tx, status).catch((e) => {
+          this.logger.debug(
+            `An error occurred while handling tx [${tx.txId}] status change in callback [${idCallbackPair[0]}]: ${e}`
+          );
+          if (e instanceof Error && e.stack) this.logger.debug(e.stack);
+        });
+      }
+    } else
       this.logger.debug(
         `No callback function is set for type [${tx.txType}] and status [${status}]`
       );
@@ -219,6 +390,7 @@ export class TxPot {
    * @param tx
    */
   protected processSignedTx = async (tx: TransactionEntity): Promise<void> => {
+    if (!(await this.isSubmitAllowed(tx))) return;
     const manager = this.getChainManager(tx.chain);
     try {
       await manager.submitTransaction(tx.serializedTx);
@@ -261,8 +433,19 @@ export class TxPot {
 
         if (isValidTx && isValidToType) {
           // tx is valid. resending...
-          this.logger.info(`Tx [${tx.txId}] is still valid. Resending tx...`);
-          await manager.submitTransaction(tx.serializedTx);
+          this.logger.info(
+            `Tx [${tx.txId}] is still valid. Attempting resend...`
+          );
+          if (await this.isSubmitAllowed(tx)) {
+            try {
+              await manager.submitTransaction(tx.serializedTx);
+            } catch (e) {
+              this.logger.warn(
+                `Failed to submit tx [${tx.txId}] to chain [${tx.chain}]: ${e}`
+              );
+              if (e instanceof Error && e.stack) this.logger.warn(e.stack);
+            }
+          }
         } else {
           // tx seems invalid. reset status if enough blocks past.
           await this.setTransactionAsInvalid(tx);
@@ -284,8 +467,11 @@ export class TxPot {
    * - process sent txs
    */
   update = async (): Promise<void> => {
-    // process signed txs
+    // fetch signed and sent txs
     const signedTxs = await this.getTxsByStatus(TransactionStatus.SIGNED);
+    const sentTxs = await this.getTxsByStatus(TransactionStatus.SENT);
+
+    // process signed txs
     for (const tx of signedTxs) {
       try {
         await this.processSignedTx(tx);
@@ -301,7 +487,6 @@ export class TxPot {
     );
 
     // process sent txs
-    const sentTxs = await this.getTxsByStatus(TransactionStatus.SENT);
     for (const tx of sentTxs) {
       try {
         await this.processesSentTx(tx);
@@ -344,13 +529,16 @@ export class TxPot {
 
   /**
    * inserts a new transaction into db
+   *   Note: make sure to set `lastCheck` field if initialStatus is `signed` or `sent`
    * @param txId
    * @param chain
    * @param txType
    * @param requiredSign
    * @param serializedTx
    * @param initialStatus
-   * @param lastCheck
+   * @param lastCheck last blockchain height that tx was valid
+   * @param extra
+   * @param extra2
    */
   addTx = async (
     txId: string,
@@ -359,7 +547,9 @@ export class TxPot {
     requiredSign: number,
     serializedTx: string,
     initialStatus = TransactionStatus.APPROVED,
-    lastCheck = 0
+    lastCheck = 0,
+    extra?: string | null,
+    extra2?: string | null
   ): Promise<void> => {
     await this.txRepository.insert({
       txId: txId,
@@ -372,6 +562,8 @@ export class TxPot {
       failedInSign: false,
       signFailedCount: 0,
       serializedTx: serializedTx,
+      extra: extra,
+      extra2: extra2,
     });
   };
 
@@ -516,4 +708,21 @@ export class TxPot {
       where: options.map(txOptionToClause),
     });
   };
+
+  /**
+   * updates extra fields of a transaction
+   * @param txId
+   * @param chain
+   * @param extra
+   * @param extra2
+   */
+  updateExtra = async (
+    txId: string,
+    chain: string,
+    extra?: string | null,
+    extra2?: string | null
+  ): Promise<void> => {
+    if (extra === undefined && extra2 === undefined) return;
+    await this.txRepository.update({ txId, chain }, { extra, extra2 });
+  };
 }

package/lib/transaction/types.ts

@@ -36,7 +36,7 @@ export interface TxOptions {
   txType?: string;
   status?: FieldOption<TransactionStatus>;
   failedInSign?: boolean;
-  extra?: FieldValue<string>;
+  extra?: FieldValue<string | null>;
 }
 
 export class UnregisteredChain extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/tx-pot",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "a Typescript package to manage transactions storage, sign, submit and related processes",
   "repository": "@rosen-bridge/tx-pot",
   "license": "GPL-3.0",

package/tests/transaction/TestTxPot.ts

@@ -1,5 +1,5 @@
 import { DataSource } from 'typeorm';
-import { AbstractLogger } from '@rosen-bridge/logger-interface';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { TransactionEntity, TransactionStatus, TxPot } from '../../lib';
 
 export class TestTxPot extends TxPot {