capitalisk-dex 17.2.2 → 17.3.1

package/defaults/config.js

@@ -1,14 +1,17 @@
 module.exports = {
   passiveMode: false,
   priceDecimalPrecision: null,
-  initRetryDelay: 5000,
+  initRetryDelay: 20000,
   multisigExpiry: 86400000,
   multisigExpiryCheckInterval: 60000,
   multisigFlushInterval: 15000,
   multisigReadyDelay: 5000,
   multisigMaxBatchSize: 25,
+  multisigRetryInterval: 60000,
   recentTransfersExpiry: 1800000,
   signatureFlushInterval: 5000,
+  signatureReadyDelay: 10000,
+  signatureRetryInterval: 60000,
   signatureMaxBatchSize: 400,
   orderBookSnapshotFinality: 303,
   orderBookUpdateSnapshotDirPath: 'dex-update-snapshots',

package/index.js

@@ -21,8 +21,11 @@ const { CAPITALISK_DEX_PASSWORD } = process.env;
 const CIPHER_ALGORITHM = 'aes-192-cbc';
 const CIPHER_KEY = CAPITALISK_DEX_PASSWORD ? crypto.scryptSync(CAPITALISK_DEX_PASSWORD, 'salt', 24) : undefined;
 const CIPHER_IV = Buffer.alloc(16, 0);
-const DEFAULT_INIT_RETRY_DELAY = 5000;
+const DEFAULT_INIT_RETRY_DELAY = 20000;
 const DEFAULT_MULTISIG_READY_DELAY = 5000;
+const DEFAULT_MULTISIG_RETRY_INTERVAL = 60000;
+const DEFAULT_SIGNATURE_READY_DELAY = 10000;
+const DEFAULT_SIGNATURE_RETRY_INTERVAL = 60000;
 const DEFAULT_PROTOCOL_EXCLUDE_REASON = false;
 const DEFAULT_PROTOCOL_MAX_ARGUMENT_LENGTH = 64;
 const DEFAULT_PRICE_DECIMAL_PRECISION = 4;
@@ -110,6 +113,9 @@ module.exports = class CapitaliskDEXModule {
     this.quoteAddress = quoteChainOptions.multisigAddress;
     this.initRetryDelay = this.options.initRetryDelay || DEFAULT_INIT_RETRY_DELAY;
     this.multisigReadyDelay = this.options.multisigReadyDelay || DEFAULT_MULTISIG_READY_DELAY;
+    this.signatureReadyDelay = this.options.signatureReadyDelay || DEFAULT_SIGNATURE_READY_DELAY;
+    this.multisigRetryInterval = this.options.multisigRetryInterval || DEFAULT_MULTISIG_RETRY_INTERVAL;
+    this.signatureRetryInterval = this.options.signatureRetryInterval || DEFAULT_SIGNATURE_RETRY_INTERVAL;
 
     this.priceDecimalPrecision = this.options.priceDecimalPrecision == null ?
       DEFAULT_PRICE_DECIMAL_PRECISION : this.options.priceDecimalPrecision;
@@ -805,9 +811,16 @@ module.exports = class CapitaliskDEXModule {
     processedSignerAddressSet.add(signerAddress);
     transaction.signatures.push(signaturePacket);
 
+    let now = Date.now();
+
+    if (transfer.signatureBroadcastTimestamps[signerAddress] == null) {
+      transfer.signatureBroadcastTimestamps[signerAddress] = now;
+    }
+
     let signatureQuota = this._getSignatureQuota(targetChain, transaction);
     if (signatureQuota >= 0 && transfer.readyTimestamp == null) {
-      transfer.readyTimestamp = Date.now();
+      transfer.readyTimestamp = now;
+      transfer.multisigBroadcastTimestamp = now + this.multisigReadyDelay;
     }
   }
 
@@ -822,43 +835,61 @@ module.exports = class CapitaliskDEXModule {
   }
 
   flushPendingMultisigTransactions() {
-    let transactionsToBroadcastPerChain = {};
+    let transfersToBroadcastPerChain = {};
     let now = Date.now();
 
     for (let transfer of this.pendingTransfers.values()) {
-      if (transfer.readyTimestamp != null && transfer.readyTimestamp + this.multisigReadyDelay <= now) {
-        if (!transactionsToBroadcastPerChain[transfer.targetChain]) {
-          transactionsToBroadcastPerChain[transfer.targetChain] = [];
+      if (transfer.multisigBroadcastTimestamp != null && transfer.multisigBroadcastTimestamp <= now) {
+        if (!transfersToBroadcastPerChain[transfer.targetChain]) {
+          transfersToBroadcastPerChain[transfer.targetChain] = [];
         }
-        transactionsToBroadcastPerChain[transfer.targetChain].push(transfer.transaction);
+        transfersToBroadcastPerChain[transfer.targetChain].push(transfer);
       }
     }
 
-    let chainSymbolList = Object.keys(transactionsToBroadcastPerChain);
+    let chainSymbolList = Object.keys(transfersToBroadcastPerChain);
     for (let chainSymbol of chainSymbolList) {
-      let maxBatchSize = this.options.multisigMaxBatchSize;
-      let transactionsToBroadcast = transactionsToBroadcastPerChain[chainSymbol].slice(0, maxBatchSize);
+      let transfersToBroadcast = transfersToBroadcastPerChain[chainSymbol]
+        .slice(0, this.options.multisigMaxBatchSize);
+
+      for (let transfer of transfersToBroadcast) {
+        transfer.multisigBroadcastTimestamp = now + this.multisigRetryInterval;
+      }
+
+      let transactionsToBroadcast = transfersToBroadcast
+        .map(transfer => transfer.transaction);
       this._broadcastTransactionsToChain(chainSymbol, transactionsToBroadcast);
     }
   }
 
   flushPendingSignatures() {
-    let signaturesToBroadcast = [];
+    let pendingSignatureInfoList = [];
+    let now = Date.now();
 
     for (let transfer of this.pendingTransfers.values()) {
       for (let signaturePacket of transfer.transaction.signatures) {
-        signaturesToBroadcast.push({
-          signaturePacket,
-          transactionId: transfer.transaction.id
-        });
+        let broadcastTimestamp = transfer.signatureBroadcastTimestamps[signaturePacket.signerAddress];
+        if (broadcastTimestamp != null && broadcastTimestamp <= now) {
+          pendingSignatureInfoList.push({
+            signaturePacket,
+            transactionId: transfer.transaction.id,
+            transfer
+          });
+        }
       }
     }
 
-    if (signaturesToBroadcast.length) {
-      let maxBatchSize = this.options.signatureMaxBatchSize;
-      this._broadcastSignaturesToSubnet(
-        signaturesToBroadcast.slice(0, maxBatchSize)
-      );
+    if (pendingSignatureInfoList.length) {
+      let signatureInfosToBroadcast = pendingSignatureInfoList.slice(0, this.options.signatureMaxBatchSize);
+      for (let signatureInfo of signatureInfosToBroadcast) {
+        let { signaturePacket, transfer } = signatureInfo;
+        transfer.signatureBroadcastTimestamps[signaturePacket.signerAddress] = Date.now() + this.signatureRetryInterval;
+      }
+      let signaturesToBroadcast = signatureInfosToBroadcast.map(signatureInfo => {
+        let { transfer, ...signatureData } = signatureInfo;
+        return signatureData;
+      });
+      this._broadcastSignaturesToSubnet(signaturesToBroadcast);
     }
   }
 
@@ -1172,7 +1203,7 @@ module.exports = class CapitaliskDEXModule {
         `Failed to load initial snapshot because of error: ${error.message} - DEX node will start with an empty order book`
       );
 
-      while (!this.processedHeights[this.baseChainSymbol] || !this.processedHeights[this.quoteChainSymbol]) {
+      while (true) {
         try {
           let [baseMaxHeight, quoteMaxHeight] = await Promise.all([
             this._getMaxBlockHeight(this.baseChainSymbol, false),
@@ -1185,31 +1216,37 @@ module.exports = class CapitaliskDEXModule {
             this.logger.error(`The ${this.quoteChainSymbol} chain had a height of 0`);
           }
           if (!baseMaxHeight || !quoteMaxHeight) {
-            this.logger.debug('Retrying chain time initialization...');
-            await wait(this.initRetryDelay);
-            continue;
+            throw new Error('Invalid chain heights');
           }
           this.processedHeights[this.baseChainSymbol] = baseMaxHeight;
           this.processedHeights[this.quoteChainSymbol] = quoteMaxHeight;
-        } catch (orderBookInitError) {
-          throw new Error(
-            `Failed to initialize new order book because of error: ${orderBookInitError.message}`
+          break;
+        } catch (initHeightError) {
+          this.logger.error(
+            `Failed to initialize last processed heights because of error: ${initHeightError.message}`
           );
+          this.logger.debug('Retrying initialization of last processed heights...');
+          await wait(this.initRetryDelay);
         }
       }
     }
 
-    try {
-      let [baseChainMaxBlock, quoteChainMaxBlock] = await Promise.all([
-        this._getBlockAtHeight(this.baseChainSymbol, this.processedHeights[this.baseChainSymbol]),
-        this._getBlockAtHeight(this.quoteChainSymbol, this.processedHeights[this.quoteChainSymbol])
-      ]);
-      this.lastProcessedBlocks[this.baseChainSymbol] = baseChainMaxBlock;
-      this.lastProcessedBlocks[this.quoteChainSymbol] = quoteChainMaxBlock;
-    } catch (error) {
-      throw new Error(
-        `Failed to load last processed blocks because of error: ${error.message}`
-      );
+    while (true) {
+      try {
+        let [baseChainMaxBlock, quoteChainMaxBlock] = await Promise.all([
+          this._getBlockAtHeight(this.baseChainSymbol, this.processedHeights[this.baseChainSymbol]),
+          this._getBlockAtHeight(this.quoteChainSymbol, this.processedHeights[this.quoteChainSymbol])
+        ]);
+        this.lastProcessedBlocks[this.baseChainSymbol] = baseChainMaxBlock;
+        this.lastProcessedBlocks[this.quoteChainSymbol] = quoteChainMaxBlock;
+        break;
+      } catch (error) {
+        this.logger.error(
+          `Failed to initialize last processed blocks because of error: ${error.message}`
+        );
+        this.logger.debug('Retrying initialization of last processed blocks...');
+        await wait(this.initRetryDelay);
+      }
     }
 
     await Promise.all(
@@ -2723,6 +2760,7 @@ module.exports = class CapitaliskDEXModule {
     if (this.pendingTransfers.has(preparedTxn.id)) {
       this.pendingTransfers.delete(preparedTxn.id);
     }
+    let now = Date.now();
     let transfer = {
       id: preparedTxn.id,
       transaction: preparedTxn,
@@ -2730,7 +2768,10 @@ module.exports = class CapitaliskDEXModule {
       targetChain,
       processedSignerAddressSet,
       height: transactionData.height,
-      timestamp: Date.now(),
+      timestamp: now,
+      signatureBroadcastTimestamps: {
+        [multisigSignaturePacket.signerAddress]: now + this.signatureReadyDelay
+      },
       ...extraTransferData
     };
     this.pendingTransfers.set(preparedTxn.id, transfer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capitalisk-dex",
-  "version": "17.2.2",
+  "version": "17.3.1",
   "description": "Decentralized exchange module.",
   "main": "index.js",
   "scripts": {