fix: waitForTransactionToBeProvable not waiting for blocks

lib/externalApis/drive/fetchProofForStateTransitionFactory.js

@@ -0,0 +1,35 @@
+/**
+ * @param {DriveClient} driveClient
+ * @return {fetchProofForStateTransition}
+ */
+function fetchProofForStateTransitionFactory(driveClient) {
+  /**
+   * @typedef {fetchProofForStateTransition}
+   * @param {AbstractStateTransition} stateTransition
+   * @return {Promise<Object>}
+   */
+  async function fetchProofForStateTransition(stateTransition) {
+    const modifiedIds = stateTransition.getModifiedDataIds();
+
+    let proof;
+    if (stateTransition.isDocumentStateTransition()) {
+      ({ documentsProof: proof } = await driveClient.fetchProofs(
+        { documentIds: modifiedIds },
+      ));
+    } else if (stateTransition.isIdentityStateTransition()) {
+      ({ identitiesProof: proof } = await driveClient.fetchProofs(
+        { identityIds: modifiedIds },
+      ));
+    } else if (stateTransition.isDataContractStateTransition()) {
+      ({ dataContractsProof: proof } = await driveClient.fetchProofs(
+        { dataContractIds: modifiedIds },
+      ));
+    }
+
+    return proof;
+  }
+
+  return fetchProofForStateTransition;
+}
+
+module.exports = fetchProofForStateTransitionFactory;

lib/externalApis/tenderdash/blockchainListener/BlockchainListener.js

@@ -0,0 +1,81 @@
+const crypto = require('crypto');
+
+const EventEmitter = require('events');
+
+const TX_QUERY = 'tm.event = \'Tx\'';
+const NEW_BLOCK_QUERY = 'tm.event = \'NewBlock\'';
+const EVENTS = {
+  NEW_BLOCK: 'block',
+};
+
+class BlockchainListener extends EventEmitter {
+  /**
+   * @param {WsClient} tenderdashWsClient
+   */
+  constructor(tenderdashWsClient) {
+    super();
+    this.wsClient = tenderdashWsClient;
+  }
+
+  /**
+   * Returns an event name for a specific hash
+   *
+   * @param {string} transactionHashString
+   * @return {string}
+   */
+  static getTransactionEventName(transactionHashString) {
+    return `transaction:${transactionHashString}`;
+  }
+
+  /**
+   *
+   * @param transactionHashString
+   * @return {string}
+   */
+  static getTransactionAddedToTheBlockEventName(transactionHashString) {
+    return `blockTransactionAdded:${transactionHashString}`;
+  }
+
+  /**
+   * Subscribe to blocks and transaction results
+   */
+  start() {
+    // Emit transaction results
+    this.wsClient.subscribe(TX_QUERY);
+    this.wsClient.on(TX_QUERY, (message) => {
+      const hashArray = message && message.events ? message.events['tx.hash'] : null;
+      const hashString = Array.isArray(hashArray) && hashArray[0];
+      if (!hashString) {
+        return;
+      }
+
+      this.emit(BlockchainListener.getTransactionEventName(hashString), message);
+    });
+
+    // Emit blocks and contained transactions
+    this.wsClient.subscribe(NEW_BLOCK_QUERY);
+    this.wsClient.on(NEW_BLOCK_QUERY, (message) => {
+      this.emit(EVENTS.NEW_BLOCK, message);
+
+      // Emit transaction hashes from block
+      message.data.value.block.data.txs.forEach((base64tx) => {
+        const transaction = Buffer.from(base64tx, 'base64');
+        const hashString = crypto.createHash('sha256')
+          .update(transaction)
+          .digest()
+          .toString('hex');
+
+        this.emit(
+          BlockchainListener.getTransactionAddedToTheBlockEventName(hashString),
+          transaction,
+        );
+      });
+    });
+  }
+}
+
+BlockchainListener.TX_QUERY = TX_QUERY;
+BlockchainListener.NEW_BLOCK_QUERY = NEW_BLOCK_QUERY;
+BlockchainListener.EVENTS = EVENTS;
+
+module.exports = BlockchainListener;

lib/externalApis/tenderdash/blockchainListener/waitForTransactionToBeProvable/transactionResult/AbstractTransactionResult.js

@@ -0,0 +1,30 @@
+class AbstractTransactionResult {
+  /**
+   * @param {Object} deliverResult
+   * @param {Buffer} transaction
+   */
+  constructor(deliverResult, transaction) {
+    this.deliverResult = deliverResult;
+    this.transaction = transaction;
+  }
+
+  /**
+   * Get TX result
+   *
+   * @return {Object}
+   */
+  getDeliverResult() {
+    return this.deliverResult;
+  }
+
+  /**
+   * Get transaction
+   *
+   * @return {Buffer}
+   */
+  getTransaction() {
+    return this.transaction;
+  }
+}
+
+module.exports = AbstractTransactionResult;

lib/externalApis/tenderdash/blockchainListener/waitForTransactionToBeProvable/transactionResult/TransactionErrorResult.js

@@ -0,0 +1,7 @@
+const AbstractTransactionResult = require('./AbstractTransactionResult');
+
+class TransactionErrorResult extends AbstractTransactionResult {
+
+}
+
+module.exports = TransactionErrorResult;

lib/externalApis/tenderdash/blockchainListener/waitForTransactionToBeProvable/transactionResult/TransactionOkResult.js

@@ -0,0 +1,7 @@
+const AbstractTransactionResult = require('./AbstractTransactionResult');
+
+class TransactionOkResult extends AbstractTransactionResult {
+
+}
+
+module.exports = TransactionOkResult;

lib/externalApis/tenderdash/blockchainListener/waitForTransactionToBeProvable/waitForTransactionCommitment.js

@@ -0,0 +1,54 @@
+const BlockchainListener = require('../BlockchainListener');
+
+/**
+ * @typedef {waitForTransactionCommitment}
+ * @param {BlockchainListener} blockchainListener
+ * @param {string} hashString
+ * @return {{
+ *    promise: Promise<void>,
+ *    detach: Function
+ * }}
+ */
+function waitForTransactionCommitment(blockchainListener, hashString) {
+  const txInBlockTopic = BlockchainListener
+    .getTransactionAddedToTheBlockEventName(hashString.toLowerCase());
+
+  let txInBlockHandler;
+  let newBlockHandler;
+
+  // Note that this will resolve only after two blocks. That is because the first block will
+  // flip the 'seenTransaction' toggle to true, and transaction will become provable
+  // only on the next block after the block it was included into
+  const promise = new Promise(((resolve) => {
+    let seenTransaction = false;
+
+    txInBlockHandler = () => {
+      seenTransaction = true;
+    };
+
+    newBlockHandler = () => {
+      if (!seenTransaction) {
+        return;
+      }
+
+      blockchainListener.off(BlockchainListener.EVENTS.NEW_BLOCK, newBlockHandler);
+
+      resolve();
+    };
+
+    blockchainListener.once(txInBlockTopic, txInBlockHandler);
+    blockchainListener.on(BlockchainListener.EVENTS.NEW_BLOCK, newBlockHandler);
+  }));
+
+  const detach = () => {
+    blockchainListener.off(txInBlockTopic, txInBlockHandler);
+    blockchainListener.off(BlockchainListener.EVENTS.NEW_BLOCK, newBlockHandler);
+  };
+
+  return {
+    promise,
+    detach,
+  };
+}
+
+module.exports = waitForTransactionCommitment;

lib/externalApis/tenderdash/blockchainListener/waitForTransactionToBeProvable/waitForTransactionResult.js

@@ -0,0 +1,52 @@
+const BlockchainListener = require('../BlockchainListener');
+const TransactionErrorResult = require('./transactionResult/TransactionErrorResult');
+const TransactionOkResult = require('./transactionResult/TransactionOkResult');
+
+/**
+ * @typedef {waitForTransactionResult}
+ * @param {BlockchainListener} blockchainListener
+ * @param {string} hashString - Transaction hash string
+ * @return {{
+ *    promise: Promise<TransactionOkResult|TransactionErrorResult>,
+ *    detach: Function
+ * }}
+ */
+function waitForTransactionResult(blockchainListener, hashString) {
+  const topic = BlockchainListener.getTransactionEventName(hashString);
+
+  let handler;
+
+  const promise = new Promise((resolve, reject) => {
+    handler = ({ data: { value: { TxResult: txResult } } }) => {
+      blockchainListener.off(topic, handler);
+
+      const { result: deliverResult, tx } = txResult;
+
+      const txBuffer = Buffer.from(tx, 'base64');
+
+      if (deliverResult && deliverResult.code !== undefined && deliverResult.code !== 0) {
+        // If a transaction result is error we don't need to wait for next block
+        return reject(
+          new TransactionErrorResult(deliverResult, txBuffer),
+        );
+      }
+
+      return resolve(
+        new TransactionOkResult(deliverResult, txBuffer),
+      );
+    };
+
+    blockchainListener.on(topic, handler);
+  });
+
+  const detach = () => {
+    blockchainListener.off(topic, handler);
+  };
+
+  return {
+    promise,
+    detach,
+  };
+}
+
+module.exports = waitForTransactionResult;