@rosen-bridge/tx-pot 0.1.0

package/dist/transaction/TxPot.js

@@ -0,0 +1,386 @@
+import { TransactionEntity } from '../db/entities/TransactionEntity';
+import { DummyLogger } from '@rosen-bridge/logger-interface';
+import { SigningStatus, TransactionStatus, UnregisteredChain, } from './types';
+import { txOptionToClause } from './utils';
+export class TxPot {
+    static instance;
+    txRepository;
+    chains = new Map();
+    validators = new Map();
+    txTypeCallbacks = new Map();
+    logger;
+    constructor(dataSource, logger) {
+        this.txRepository = dataSource.getRepository(TransactionEntity);
+        this.logger = logger ?? new DummyLogger();
+        this.logger.debug('TxPot instantiated');
+    }
+    /**
+     * initiates TxPot
+     * @param dataSource typeorm data source
+     * @param logger
+     * @returns
+     */
+    static setup = (dataSource, logger) => {
+        TxPot.instance = new TxPot(dataSource, logger);
+        return TxPot.instance;
+    };
+    /**
+     * returns TxPot instance (throws error if none exists)
+     * @returns TxPot instance
+     */
+    static getInstance = () => {
+        if (!TxPot.instance)
+            throw Error(`TxPot instance doesn't exist`);
+        return TxPot.instance;
+    };
+    /**
+     * registers a chain to TxPot
+     * @param chain
+     * @param chainManager
+     */
+    registerChain = (chain, chainManager) => {
+        this.chains.set(chain, chainManager);
+        this.logger.debug(`A TxPot chain manager is registered for chain [${chain}]`);
+    };
+    /**
+     * registers a validator function
+     * @param chain
+     * @param txType
+     * @param validator
+     */
+    registerValidator = (chain, txType, validator) => {
+        let chainValidators = this.validators.get(chain);
+        if (!chainValidators) {
+            chainValidators = new Map();
+            this.validators.set(chain, chainValidators);
+        }
+        chainValidators.set(txType, validator);
+        this.logger.debug(`A tx validator function is registered for chain [${chain}] and type [${txType}]`);
+    };
+    /**
+     * registers a callback function
+     *  the callback will be called when status of any transactions
+     *  of given type changes to given status
+     * @param txType
+     * @param status
+     * @param callback
+     */
+    registerCallback = (txType, status, callback) => {
+        let typeCallbacks = this.txTypeCallbacks.get(txType);
+        if (!typeCallbacks) {
+            typeCallbacks = new Map();
+            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}]`);
+    };
+    /**
+     * returns chain manager for given chain
+     *  throws error if no manager is registered for it
+     * @param chain
+     */
+    getChainManager = (chain) => {
+        const manager = this.chains.get(chain);
+        if (!manager)
+            throw new UnregisteredChain(`No manager is registered for chain [${chain}]`);
+        return manager;
+    };
+    /**
+     * sets the tx as invalid if enough blocks is passed from last check
+     * @param tx
+     */
+    setTransactionAsInvalid = async (tx) => {
+        const manager = this.getChainManager(tx.chain);
+        const currentHeight = await manager.getHeight();
+        const requiredConfirmation = manager.getTxRequiredConfirmation(tx.txType);
+        if (currentHeight - tx.lastCheck >= requiredConfirmation) {
+            await this.setTxStatus(tx, TransactionStatus.INVALID);
+            this.logger.info(`Tx [${tx.txId}] is invalid`);
+        }
+        else {
+            this.logger.info(`Tx [${tx.txId}] seems invalid. Waiting for enough confirmation of this proposition [${currentHeight - tx.lastCheck}/${requiredConfirmation}]`);
+        }
+    };
+    /**
+     * validates a transaction
+     * returns true if no validator functions is set or tx is valid
+     * otherwise handle the tx as invalid and returns false
+     * @param tx
+     */
+    validateTx = async (tx) => {
+        const validator = this.validators.get(tx.chain)?.get(tx.txType);
+        if (validator === 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;
+        await this.setTransactionAsInvalid(tx);
+        return false;
+    };
+    /**
+     * updates the status of a tx
+     * @param txKey tx id and chain
+     * @param status new status
+     */
+    setTxStatus = async (tx, status) => {
+        await this.txRepository.update({
+            txId: tx.txId,
+            chain: tx.chain,
+        }, {
+            status: status,
+            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
+            this.logger.debug(`No callback function is set for type [${tx.txType}] and status [${status}]`);
+    };
+    /**
+     * @returns current timestamp in seconds and string format
+     */
+    currentTime = () => String(Math.round(Date.now() / 1000));
+    /**
+     * submits the signed transaction to the blockchain
+     * @param tx
+     */
+    processSignedTx = async (tx) => {
+        const manager = this.getChainManager(tx.chain);
+        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);
+        }
+        await this.setTxStatus(tx, TransactionStatus.SENT);
+    };
+    /**
+     * processes the sent transaction
+     * @param tx
+     */
+    processesSentTx = async (tx) => {
+        const manager = this.getChainManager(tx.chain);
+        const txConfirmation = await manager.getTxConfirmation(tx.txId);
+        const requiredConfirmation = manager.getTxRequiredConfirmation(tx.txType);
+        if (txConfirmation >= requiredConfirmation) {
+            // tx is confirmed enough
+            await this.setTxStatus(tx, TransactionStatus.COMPLETED);
+        }
+        else if (txConfirmation === -1) {
+            // tx is not mined, checking mempool...
+            if (await manager.isTxInMempool(tx.txId)) {
+                // tx is in mempool, updating last check...
+                const height = await manager.getHeight();
+                await this.updateTxLastCheck(tx.txId, tx.chain, height);
+                this.logger.info(`Tx [${tx.txId}] is in mempool`);
+            }
+            else {
+                // tx is not in mempool, checking if tx is still valid
+                const isValidTx = await manager.isTxValid(tx.serializedTx, SigningStatus.Signed);
+                const isValidToType = await this.validateTx(tx);
+                if (isValidTx && isValidToType) {
+                    // tx is valid. resending...
+                    this.logger.info(`Tx [${tx.txId}] is still valid. Resending tx...`);
+                    await manager.submitTransaction(tx.serializedTx);
+                }
+                else {
+                    // tx seems invalid. reset status if enough blocks past.
+                    await this.setTransactionAsInvalid(tx);
+                }
+            }
+        }
+        else {
+            // tx is mined, but is not confirmed enough, updating last check...
+            const height = await manager.getHeight();
+            await this.updateTxLastCheck(tx.txId, tx.chain, height);
+            this.logger.info(`Tx [${tx.txId}] is in confirmation process [${txConfirmation}/${requiredConfirmation}]`);
+        }
+    };
+    /**
+     * runs all jobs of TxPot
+     * - process signed txs
+     * - process sent txs
+     */
+    update = async () => {
+        // process signed txs
+        const signedTxs = await this.getTxsByStatus(TransactionStatus.SIGNED);
+        for (const tx of signedTxs) {
+            try {
+                await this.processSignedTx(tx);
+            }
+            catch (e) {
+                this.logger.warn(`An error occurred while processing tx [${tx.txId}] with status [${TransactionStatus.SIGNED}]: ${e}`);
+                if (e instanceof Error && e.stack)
+                    this.logger.warn(e.stack);
+            }
+        }
+        this.logger.debug(`Processed [${signedTxs.length}] txs with status [${TransactionStatus.SIGNED}]`);
+        // process sent txs
+        const sentTxs = await this.getTxsByStatus(TransactionStatus.SENT);
+        for (const tx of sentTxs) {
+            try {
+                await this.processesSentTx(tx);
+            }
+            catch (e) {
+                this.logger.warn(`An error occurred while processing tx [${tx.txId}] with status [${TransactionStatus.SENT}]: ${e}`);
+                if (e instanceof Error && e.stack)
+                    this.logger.warn(e.stack);
+            }
+        }
+        this.logger.debug(`Processed [${sentTxs.length}] txs with status [${TransactionStatus.SENT}]`);
+    };
+    /**
+     * gets transactions by status
+     * @param status
+     * @param validate
+     * @returns
+     */
+    getTxsByStatus = async (status, validate = false) => {
+        const txs = await this.txRepository.find({
+            where: {
+                status: status,
+            },
+        });
+        if (!validate)
+            return txs;
+        // validate the transactions
+        const validTxs = [];
+        for (const tx of txs) {
+            if (await this.validateTx(tx))
+                validTxs.push(tx);
+        }
+        return validTxs;
+    };
+    /**
+     * inserts a new transaction into db
+     * @param txId
+     * @param chain
+     * @param txType
+     * @param requiredSign
+     * @param serializedTx
+     * @param initialStatus
+     * @param lastCheck
+     */
+    addTx = async (txId, chain, txType, requiredSign, serializedTx, initialStatus = TransactionStatus.APPROVED, lastCheck = 0) => {
+        await this.txRepository.insert({
+            txId: txId,
+            chain: chain,
+            txType: txType,
+            status: initialStatus,
+            requiredSign: requiredSign,
+            lastCheck: lastCheck,
+            lastStatusUpdate: this.currentTime(),
+            failedInSign: false,
+            signFailedCount: 0,
+            serializedTx: serializedTx,
+        });
+    };
+    /**
+     * updates the status of a tx
+     * @param txId
+     * @param chain
+     * @param status new status
+     */
+    setTxStatusById = async (txId, chain, status) => {
+        const tx = await this.txRepository.findOneOrFail({
+            where: { txId, chain },
+        });
+        await this.setTxStatus(tx, status);
+    };
+    /**
+     * updates tx info when failed in sign process
+     * @param txId
+     * @param chain
+     */
+    setTxAsSignFailed = async (txId, chain) => {
+        await this.txRepository.update({
+            txId: txId,
+            chain: chain,
+            status: TransactionStatus.IN_SIGN,
+        }, {
+            status: TransactionStatus.SIGN_FAILED,
+            lastStatusUpdate: this.currentTime(),
+            signFailedCount: () => '"signFailedCount" + 1',
+            failedInSign: true,
+        });
+    };
+    /**
+     * updates the tx and set status as signed
+     * @param txId
+     * @param chain
+     * @param serializedTx
+     * @param currentHeight current height of the blockchain
+     * @param extra
+     * @param extra2
+     */
+    setTxAsSigned = async (txId, chain, serializedTx, currentHeight, extra, extra2) => {
+        const updatedFields = {
+            serializedTx: serializedTx,
+            status: TransactionStatus.SIGNED,
+            lastStatusUpdate: this.currentTime(),
+            lastCheck: currentHeight,
+        };
+        if (extra)
+            updatedFields.extra = extra;
+        if (extra2)
+            updatedFields.extra2 = extra2;
+        await this.txRepository.update({ txId, chain }, updatedFields);
+    };
+    /**
+     * updates last check value of a tx
+     * @param txId
+     * @param chain
+     * @param currentHeight current height of the blockchain
+     */
+    updateTxLastCheck = async (txId, chain, currentHeight) => {
+        await this.txRepository.update({ txId, chain }, { lastCheck: currentHeight });
+    };
+    /**
+     * updates failedInSign field of a transaction to false
+     * @param txId
+     * @param chain
+     */
+    resetFailedInSign = async (txId, chain) => {
+        await this.txRepository.update({ txId, chain }, {
+            failedInSign: false,
+        });
+    };
+    /**
+     * updates requiredSign field of a transaction
+     * @param txId
+     * @param chain
+     * @param requiredSign
+     */
+    updateRequiredSign = async (txId, chain, requiredSign) => {
+        await this.txRepository.update({ txId, chain }, {
+            requiredSign: requiredSign,
+        });
+    };
+    /**
+     * gets the transaction by its id and chain
+     * @param txId
+     * @param chain
+     */
+    getTxByKey = async (txId, chain) => {
+        return await this.txRepository.findOne({
+            where: { txId, chain },
+        });
+    };
+    /**
+     * @returns the transactions with valid status
+     */
+    getTxsQuery = (options = []) => {
+        return this.txRepository.find({
+            where: options.map(txOptionToClause),
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TxPot.js","sourceRoot":"","sources":["../../lib/transaction/TxPot.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, Repository } from 'typeorm';\nimport { TransactionEntity } from '../db/entities/TransactionEntity';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/logger-interface';\nimport {\n  CallbackFunction,\n  SigningStatus,\n  TransactionStatus,\n  TxOptions,\n  UnregisteredChain,\n  ValidatorFunction,\n} from './types';\nimport { txOptionToClause } from './utils';\nimport { AbstractPotChainManager } from '../network/AbstractPotChainManager';\n\nexport class TxPot {\n  protected static instance: TxPot;\n  protected readonly txRepository: Repository<TransactionEntity>;\n  protected chains = new Map<string, AbstractPotChainManager>();\n  protected validators = new Map<string, Map<string, ValidatorFunction>>();\n  protected txTypeCallbacks = new Map<\n    string,\n    Map<TransactionStatus, CallbackFunction>\n  >();\n  protected logger: AbstractLogger;\n\n  protected constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    this.txRepository = dataSource.getRepository(TransactionEntity);\n    this.logger = logger ?? new DummyLogger();\n    this.logger.debug('TxPot instantiated');\n  }\n\n  /**\n   * initiates TxPot\n   * @param dataSource typeorm data source\n   * @param logger\n   * @returns\n   */\n  public static setup = (\n    dataSource: DataSource,\n    logger?: AbstractLogger\n  ): TxPot => {\n    TxPot.instance = new TxPot(dataSource, logger);\n    return TxPot.instance;\n  };\n\n  /**\n   * returns TxPot instance (throws error if none exists)\n   * @returns TxPot instance\n   */\n  public static getInstance = (): TxPot => {\n    if (!TxPot.instance) throw Error(`TxPot instance doesn't exist`);\n    return TxPot.instance;\n  };\n\n  /**\n   * registers a chain to TxPot\n   * @param chain\n   * @param chainManager\n   */\n  registerChain = (\n    chain: string,\n    chainManager: AbstractPotChainManager\n  ): void => {\n    this.chains.set(chain, chainManager);\n    this.logger.debug(\n      `A TxPot chain manager is registered for chain [${chain}]`\n    );\n  };\n\n  /**\n   * registers a validator function\n   * @param chain\n   * @param txType\n   * @param validator\n   */\n  registerValidator = (\n    chain: string,\n    txType: string,\n    validator: ValidatorFunction\n  ): void => {\n    let chainValidators = this.validators.get(chain);\n    if (!chainValidators) {\n      chainValidators = new Map<string, ValidatorFunction>();\n      this.validators.set(chain, chainValidators);\n    }\n\n    chainValidators.set(txType, validator);\n    this.logger.debug(\n      `A tx validator function is registered for chain [${chain}] and type [${txType}]`\n    );\n  };\n\n  /**\n   * registers a callback function\n   *  the callback will be called when status of any transactions\n   *  of given type changes to given status\n   * @param txType\n   * @param status\n   * @param callback\n   */\n  registerCallback = (\n    txType: string,\n    status: TransactionStatus,\n    callback: CallbackFunction\n  ): void => {\n    let typeCallbacks = this.txTypeCallbacks.get(txType);\n    if (!typeCallbacks) {\n      typeCallbacks = new Map<TransactionStatus, CallbackFunction>();\n      this.txTypeCallbacks.set(txType, typeCallbacks);\n    }\n\n    typeCallbacks.set(status, callback);\n    this.logger.debug(\n      `A tx status callback function is registered for type [${txType}] and status [${status}]`\n    );\n  };\n\n  /**\n   * returns chain manager for given chain\n   *  throws error if no manager is registered for it\n   * @param chain\n   */\n  protected getChainManager = (chain: string): AbstractPotChainManager => {\n    const manager = this.chains.get(chain);\n    if (!manager)\n      throw new UnregisteredChain(\n        `No manager is registered for chain [${chain}]`\n      );\n    return manager;\n  };\n\n  /**\n   * sets the tx as invalid if enough blocks is passed from last check\n   * @param tx\n   */\n  protected setTransactionAsInvalid = async (\n    tx: TransactionEntity\n  ): Promise<void> => {\n    const manager = this.getChainManager(tx.chain);\n\n    const currentHeight = await manager.getHeight();\n    const requiredConfirmation = manager.getTxRequiredConfirmation(tx.txType);\n\n    if (currentHeight - tx.lastCheck >= requiredConfirmation) {\n      await this.setTxStatus(tx, TransactionStatus.INVALID);\n      this.logger.info(`Tx [${tx.txId}] is invalid`);\n    } else {\n      this.logger.info(\n        `Tx [${\n          tx.txId\n        }] seems invalid. Waiting for enough confirmation of this proposition [${\n          currentHeight - tx.lastCheck\n        }/${requiredConfirmation}]`\n      );\n    }\n  };\n\n  /**\n   * validates a transaction\n   * returns true if no validator functions is set or tx is valid\n   * otherwise handle the tx as invalid and returns false\n   * @param tx\n   */\n  protected validateTx = async (tx: TransactionEntity): Promise<boolean> => {\n    const validator = this.validators.get(tx.chain)?.get(tx.txType);\n    if (validator === undefined) {\n      // tx is valid since no validator is found\n      this.logger.debug(\n        `No validator function is found for chain [${tx.chain}] and type [${tx.txType}]`\n      );\n      return true;\n    }\n    if (await validator(tx)) return true;\n\n    await this.setTransactionAsInvalid(tx);\n    return false;\n  };\n\n  /**\n   * updates the status of a tx\n   * @param txKey tx id and chain\n   * @param status new status\n   */\n  protected setTxStatus = async (\n    tx: TransactionEntity,\n    status: TransactionStatus\n  ): Promise<void> => {\n    await this.txRepository.update(\n      {\n        txId: tx.txId,\n        chain: tx.chain,\n      },\n      {\n        status: status,\n        lastStatusUpdate: this.currentTime(),\n      }\n    );\n    const callback = this.txTypeCallbacks.get(tx.txType)?.get(status);\n    if (callback)\n      callback(tx, status).catch((e) => {\n        this.logger.debug(\n          `An error occurred while handling tx [${tx.txId}] status change: ${e}`\n        );\n        if (e instanceof Error && e.stack) this.logger.debug(e.stack);\n      });\n    else\n      this.logger.debug(\n        `No callback function is set for type [${tx.txType}] and status [${status}]`\n      );\n  };\n\n  /**\n   * @returns current timestamp in seconds and string format\n   */\n  protected currentTime = () => String(Math.round(Date.now() / 1000));\n\n  /**\n   * submits the signed transaction to the blockchain\n   * @param tx\n   */\n  protected processSignedTx = async (tx: TransactionEntity): Promise<void> => {\n    const manager = this.getChainManager(tx.chain);\n    try {\n      await manager.submitTransaction(tx.serializedTx);\n    } catch (e) {\n      this.logger.warn(\n        `Failed to submit tx [${tx.txId}] to chain [${tx.chain}]: ${e}`\n      );\n      if (e instanceof Error && e.stack) this.logger.warn(e.stack);\n    }\n    await this.setTxStatus(tx, TransactionStatus.SENT);\n  };\n\n  /**\n   * processes the sent transaction\n   * @param tx\n   */\n  protected processesSentTx = async (tx: TransactionEntity): Promise<void> => {\n    const manager = this.getChainManager(tx.chain);\n\n    const txConfirmation = await manager.getTxConfirmation(tx.txId);\n    const requiredConfirmation = manager.getTxRequiredConfirmation(tx.txType);\n\n    if (txConfirmation >= requiredConfirmation) {\n      // tx is confirmed enough\n      await this.setTxStatus(tx, TransactionStatus.COMPLETED);\n    } else if (txConfirmation === -1) {\n      // tx is not mined, checking mempool...\n      if (await manager.isTxInMempool(tx.txId)) {\n        // tx is in mempool, updating last check...\n        const height = await manager.getHeight();\n        await this.updateTxLastCheck(tx.txId, tx.chain, height);\n        this.logger.info(`Tx [${tx.txId}] is in mempool`);\n      } else {\n        // tx is not in mempool, checking if tx is still valid\n        const isValidTx = await manager.isTxValid(\n          tx.serializedTx,\n          SigningStatus.Signed\n        );\n        const isValidToType = await this.validateTx(tx);\n\n        if (isValidTx && isValidToType) {\n          // tx is valid. resending...\n          this.logger.info(`Tx [${tx.txId}] is still valid. Resending tx...`);\n          await manager.submitTransaction(tx.serializedTx);\n        } else {\n          // tx seems invalid. reset status if enough blocks past.\n          await this.setTransactionAsInvalid(tx);\n        }\n      }\n    } else {\n      // tx is mined, but is not confirmed enough, updating last check...\n      const height = await manager.getHeight();\n      await this.updateTxLastCheck(tx.txId, tx.chain, height);\n      this.logger.info(\n        `Tx [${tx.txId}] is in confirmation process [${txConfirmation}/${requiredConfirmation}]`\n      );\n    }\n  };\n\n  /**\n   * runs all jobs of TxPot\n   * - process signed txs\n   * - process sent txs\n   */\n  update = async (): Promise<void> => {\n    // process signed txs\n    const signedTxs = await this.getTxsByStatus(TransactionStatus.SIGNED);\n    for (const tx of signedTxs) {\n      try {\n        await this.processSignedTx(tx);\n      } catch (e) {\n        this.logger.warn(\n          `An error occurred while processing tx [${tx.txId}] with status [${TransactionStatus.SIGNED}]: ${e}`\n        );\n        if (e instanceof Error && e.stack) this.logger.warn(e.stack);\n      }\n    }\n    this.logger.debug(\n      `Processed [${signedTxs.length}] txs with status [${TransactionStatus.SIGNED}]`\n    );\n\n    // process sent txs\n    const sentTxs = await this.getTxsByStatus(TransactionStatus.SENT);\n    for (const tx of sentTxs) {\n      try {\n        await this.processesSentTx(tx);\n      } catch (e) {\n        this.logger.warn(\n          `An error occurred while processing tx [${tx.txId}] with status [${TransactionStatus.SENT}]: ${e}`\n        );\n        if (e instanceof Error && e.stack) this.logger.warn(e.stack);\n      }\n    }\n    this.logger.debug(\n      `Processed [${sentTxs.length}] txs with status [${TransactionStatus.SENT}]`\n    );\n  };\n\n  /**\n   * gets transactions by status\n   * @param status\n   * @param validate\n   * @returns\n   */\n  getTxsByStatus = async (\n    status: TransactionStatus,\n    validate = false\n  ): Promise<Array<TransactionEntity>> => {\n    const txs = await this.txRepository.find({\n      where: {\n        status: status,\n      },\n    });\n    if (!validate) return txs;\n\n    // validate the transactions\n    const validTxs: Array<TransactionEntity> = [];\n    for (const tx of txs) {\n      if (await this.validateTx(tx)) validTxs.push(tx);\n    }\n    return validTxs;\n  };\n\n  /**\n   * inserts a new transaction into db\n   * @param txId\n   * @param chain\n   * @param txType\n   * @param requiredSign\n   * @param serializedTx\n   * @param initialStatus\n   * @param lastCheck\n   */\n  addTx = async (\n    txId: string,\n    chain: string,\n    txType: string,\n    requiredSign: number,\n    serializedTx: string,\n    initialStatus = TransactionStatus.APPROVED,\n    lastCheck = 0\n  ): Promise<void> => {\n    await this.txRepository.insert({\n      txId: txId,\n      chain: chain,\n      txType: txType,\n      status: initialStatus,\n      requiredSign: requiredSign,\n      lastCheck: lastCheck,\n      lastStatusUpdate: this.currentTime(),\n      failedInSign: false,\n      signFailedCount: 0,\n      serializedTx: serializedTx,\n    });\n  };\n\n  /**\n   * updates the status of a tx\n   * @param txId\n   * @param chain\n   * @param status new status\n   */\n  setTxStatusById = async (\n    txId: string,\n    chain: string,\n    status: TransactionStatus\n  ): Promise<void> => {\n    const tx = await this.txRepository.findOneOrFail({\n      where: { txId, chain },\n    });\n    await this.setTxStatus(tx, status);\n  };\n\n  /**\n   * updates tx info when failed in sign process\n   * @param txId\n   * @param chain\n   */\n  setTxAsSignFailed = async (txId: string, chain: string): Promise<void> => {\n    await this.txRepository.update(\n      {\n        txId: txId,\n        chain: chain,\n        status: TransactionStatus.IN_SIGN,\n      },\n      {\n        status: TransactionStatus.SIGN_FAILED,\n        lastStatusUpdate: this.currentTime(),\n        signFailedCount: () => '\"signFailedCount\" + 1',\n        failedInSign: true,\n      }\n    );\n  };\n\n  /**\n   * updates the tx and set status as signed\n   * @param txId\n   * @param chain\n   * @param serializedTx\n   * @param currentHeight current height of the blockchain\n   * @param extra\n   * @param extra2\n   */\n  setTxAsSigned = async (\n    txId: string,\n    chain: string,\n    serializedTx: string,\n    currentHeight: number,\n    extra?: string,\n    extra2?: string\n  ): Promise<void> => {\n    const updatedFields: Partial<TransactionEntity> = {\n      serializedTx: serializedTx,\n      status: TransactionStatus.SIGNED,\n      lastStatusUpdate: this.currentTime(),\n      lastCheck: currentHeight,\n    };\n    if (extra) updatedFields.extra = extra;\n    if (extra2) updatedFields.extra2 = extra2;\n\n    await this.txRepository.update({ txId, chain }, updatedFields);\n  };\n\n  /**\n   * updates last check value of a tx\n   * @param txId\n   * @param chain\n   * @param currentHeight current height of the blockchain\n   */\n  updateTxLastCheck = async (\n    txId: string,\n    chain: string,\n    currentHeight: number\n  ): Promise<void> => {\n    await this.txRepository.update(\n      { txId, chain },\n      { lastCheck: currentHeight }\n    );\n  };\n\n  /**\n   * updates failedInSign field of a transaction to false\n   * @param txId\n   * @param chain\n   */\n  resetFailedInSign = async (txId: string, chain: string): Promise<void> => {\n    await this.txRepository.update(\n      { txId, chain },\n      {\n        failedInSign: false,\n      }\n    );\n  };\n\n  /**\n   * updates requiredSign field of a transaction\n   * @param txId\n   * @param chain\n   * @param requiredSign\n   */\n  updateRequiredSign = async (\n    txId: string,\n    chain: string,\n    requiredSign: number\n  ): Promise<void> => {\n    await this.txRepository.update(\n      { txId, chain },\n      {\n        requiredSign: requiredSign,\n      }\n    );\n  };\n\n  /**\n   * gets the transaction by its id and chain\n   * @param txId\n   * @param chain\n   */\n  getTxByKey = async (\n    txId: string,\n    chain: string\n  ): Promise<TransactionEntity | null> => {\n    return await this.txRepository.findOne({\n      where: { txId, chain },\n    });\n  };\n\n  /**\n   * @returns the transactions with valid status\n   */\n  getTxsQuery = (\n    options: Array<TxOptions> = []\n  ): Promise<TransactionEntity[]> => {\n    return this.txRepository.find({\n      where: options.map(txOptionToClause),\n    });\n  };\n}\n"]}

package/dist/transaction/types.d.ts

@@ -0,0 +1,35 @@
+import { TransactionEntity } from '../db/entities/TransactionEntity';
+export type ChainRequiredConfirmations = Record<string, number>;
+export type RequiredConfirmations = Record<string, ChainRequiredConfirmations>;
+export type ValidatorFunction = (tx: TransactionEntity) => Promise<boolean>;
+export type CallbackFunction = (tx: TransactionEntity, newStatus: TransactionStatus) => Promise<void>;
+export declare enum TransactionStatus {
+    APPROVED = "approved",
+    IN_SIGN = "in-sign",
+    SIGN_FAILED = "sign-failed",
+    SIGNED = "signed",
+    SENT = "sent",
+    INVALID = "invalid",
+    COMPLETED = "completed"
+}
+export declare enum SigningStatus {
+    Signed = 0,
+    UnSigned = 1
+}
+export type FieldValue<T> = T | Array<T>;
+export interface FieldOption<T> {
+    not: boolean;
+    value: FieldValue<T>;
+}
+export interface TxOptions {
+    txId?: FieldValue<string>;
+    chain?: string;
+    txType?: string;
+    status?: FieldOption<TransactionStatus>;
+    failedInSign?: boolean;
+    extra?: FieldValue<string>;
+}
+export declare class UnregisteredChain extends Error {
+    constructor(msg: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/transaction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../lib/transaction/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;AAE/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAC5E,MAAM,MAAM,gBAAgB,GAAG,CAC7B,EAAE,EAAE,iBAAiB,EACrB,SAAS,EAAE,iBAAiB,KACzB,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,oBAAY,iBAAiB;IAC3B,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,SAAS,cAAc;CACxB;AAED,oBAAY,aAAa;IACvB,MAAM,IAAA;IACN,QAAQ,IAAA;CACT;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACzC,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;CAC5B;AAED,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,GAAG,EAAE,MAAM;CAGxB"}

package/dist/transaction/types.js

@@ -0,0 +1,21 @@
+export var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["APPROVED"] = "approved";
+    TransactionStatus["IN_SIGN"] = "in-sign";
+    TransactionStatus["SIGN_FAILED"] = "sign-failed";
+    TransactionStatus["SIGNED"] = "signed";
+    TransactionStatus["SENT"] = "sent";
+    TransactionStatus["INVALID"] = "invalid";
+    TransactionStatus["COMPLETED"] = "completed";
+})(TransactionStatus || (TransactionStatus = {}));
+export var SigningStatus;
+(function (SigningStatus) {
+    SigningStatus[SigningStatus["Signed"] = 0] = "Signed";
+    SigningStatus[SigningStatus["UnSigned"] = 1] = "UnSigned";
+})(SigningStatus || (SigningStatus = {}));
+export class UnregisteredChain extends Error {
+    constructor(msg) {
+        super('UnregisteredChain: ' + msg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/transaction/utils.d.ts

@@ -0,0 +1,8 @@
+import { TxOptions } from './types';
+/**
+ * converts options for fetching txs to typeorm clause
+ * @param options
+ * @returns
+ */
+export declare const txOptionToClause: (options: TxOptions) => Record<string, any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/transaction/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/transaction/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,YAAa,SAAS,wBAkDlD,CAAC"}

package/dist/transaction/utils.js

@@ -0,0 +1,56 @@
+import { In, Not } from 'typeorm';
+/**
+ * converts options for fetching txs to typeorm clause
+ * @param options
+ * @returns
+ */
+export const txOptionToClause = (options) => {
+    const clause = {};
+    // add txId clause
+    if (typeof options.txId === 'string') {
+        clause.txId = options.txId;
+    }
+    else if (Array.isArray(options.txId)) {
+        clause.txId = In(options.txId);
+    }
+    // add chain clause
+    if (typeof options.chain === 'string') {
+        clause.chain = options.chain;
+    }
+    // add txType clause
+    if (typeof options.txType === 'string') {
+        clause.txType = options.txType;
+    }
+    // add status clause
+    if (options.status) {
+        if (typeof options.status.value === 'string') {
+            if (options.status.not) {
+                clause.status = Not(options.status.value);
+            }
+            else {
+                clause.status = options.status.value;
+            }
+        }
+        else if (Array.isArray(options.status.value)) {
+            if (options.status.not) {
+                clause.status = Not(In(options.status.value));
+            }
+            else {
+                clause.status = In(options.status.value);
+            }
+        }
+    }
+    // add failedInSign clause
+    if (typeof options.failedInSign === 'boolean') {
+        clause.failedInSign = options.failedInSign;
+    }
+    // add extra clause
+    if (typeof options.extra === 'string') {
+        clause.extra = options.extra;
+    }
+    else if (Array.isArray(options.extra)) {
+        clause.extra = In(options.extra);
+    }
+    return clause;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/db/entities/TransactionEntity.ts

@@ -0,0 +1,44 @@
+import { Column, Entity, PrimaryColumn } from 'typeorm';
+
+@Entity()
+export class TransactionEntity {
+  @PrimaryColumn('varchar')
+  txId: string;
+
+  @PrimaryColumn('varchar')
+  chain: string;
+
+  @Column('varchar')
+  txType: string;
+
+  @Column('varchar')
+  status: string;
+
+  @Column('integer')
+  requiredSign: number;
+
+  @Column('integer')
+  lastCheck: number;
+
+  @Column('varchar')
+  lastStatusUpdate: string;
+
+  @Column('boolean')
+  failedInSign: boolean;
+
+  @Column('integer')
+  signFailedCount: number;
+
+  @Column('varchar')
+  serializedTx: string;
+
+  @Column('varchar', {
+    nullable: true,
+  })
+  extra?: string;
+
+  @Column('varchar', {
+    nullable: true,
+  })
+  extra2?: string;
+}

package/lib/db/migrations/index.ts

@@ -0,0 +1,7 @@
+import { Migration1706350644686 } from './postgres/1706350644686-migration';
+import { Migration1706007154531 } from './sqlite/1706007154531-migration';
+
+export const migrations = {
+  sqlite: [Migration1706007154531],
+  postgres: [Migration1706350644686],
+};