@rosen-bridge/tx-pot 0.1.0

package/lib/transaction/utils.ts

@@ -0,0 +1,59 @@
+import { In, Not } from 'typeorm';
+import { TxOptions } from './types';
+
+/**
+ * converts options for fetching txs to typeorm clause
+ * @param options
+ * @returns
+ */
+export const txOptionToClause = (options: TxOptions) => {
+  const clause: Record<string, any> = {};
+
+  // 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;
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@rosen-bridge/tx-pot",
+  "version": "0.1.0",
+  "description": "a Typescript package to manage transactions storage, sign, submit and related processes",
+  "repository": "@rosen-bridge/tx-pot",
+  "license": "GPL-3.0",
+  "author": "Rosen Team",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "coverage": "npm run test -- --coverage",
+    "lint": "eslint --fix . && npm run prettify",
+    "prettify": "prettier --write . --ignore-path ./.gitignore",
+    "release": "npm run test -- --run && npm run build && npm publish --access public",
+    "test": "NODE_OPTIONS=--experimental-specifier-resolution=node vitest",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "@vitest/coverage-v8": "^1.2.2",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
+    "prettier": "2.7.1",
+    "typescript": "^5.0.0",
+    "vite-plugin-wasm": "^3.3.0",
+    "vitest": "^1.2.1"
+  },
+  "engines": {
+    "node": ">=18.12.0"
+  },
+  "dependencies": {
+    "@rosen-bridge/abstract-logger": "^1.0.0",
+    "typeorm": "^0.3.17"
+  }
+}

package/tests/db/dataSource.mock.ts

@@ -0,0 +1,18 @@
+import { DataSource } from 'typeorm';
+import { TransactionEntity, migrations } from '../../lib';
+
+export const mockDataSource = async () => {
+  const testDataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    entities: [TransactionEntity],
+    migrations: [...migrations.sqlite],
+    synchronize: false,
+    logging: false,
+  });
+
+  await testDataSource.initialize();
+  await testDataSource.runMigrations();
+
+  return testDataSource;
+};

package/tests/network/TestPotChainManager.ts

@@ -0,0 +1,23 @@
+import { AbstractPotChainManager, SigningStatus } from '../../lib';
+
+export class TestPotChainManager implements AbstractPotChainManager {
+  notImplemented = () => {
+    throw Error('Not implemented');
+  };
+
+  getHeight: () => Promise<number> = this.notImplemented;
+
+  getTxRequiredConfirmation: (txType: string) => number = this.notImplemented;
+
+  getTxConfirmation: (txId: string) => Promise<number> = this.notImplemented;
+
+  isTxValid: (
+    serializedTx: string,
+    signingStatus: SigningStatus
+  ) => Promise<boolean> = this.notImplemented;
+
+  submitTransaction: (serializedTx: string) => Promise<void> =
+    this.notImplemented;
+
+  isTxInMempool: (txId: string) => Promise<boolean> = this.notImplemented;
+}

package/tests/transaction/TestTxPot.ts

@@ -0,0 +1,32 @@
+import { DataSource } from 'typeorm';
+import { AbstractLogger } from '@rosen-bridge/logger-interface';
+import { TransactionEntity, TransactionStatus, TxPot } from '../../lib';
+
+export class TestTxPot extends TxPot {
+  protected static instance: TestTxPot;
+
+  public static setup = (
+    dataSource: DataSource,
+    logger?: AbstractLogger
+  ): TestTxPot => {
+    TestTxPot.instance = new TestTxPot(dataSource, logger);
+    return TestTxPot.instance;
+  };
+
+  callSetTransactionAsInvalid = async (tx: TransactionEntity): Promise<void> =>
+    this.setTransactionAsInvalid(tx);
+
+  callValidateTx = async (tx: TransactionEntity): Promise<boolean> =>
+    this.validateTx(tx);
+
+  callSetTxStatus = async (
+    tx: TransactionEntity,
+    status: TransactionStatus
+  ): Promise<void> => this.setTxStatus(tx, status);
+
+  callProcessSignedTx = async (tx: TransactionEntity): Promise<void> =>
+    this.processSignedTx(tx);
+
+  callProcessesSentTx = async (tx: TransactionEntity): Promise<void> =>
+    this.processesSentTx(tx);
+}