@dashevo/dapi-client 0.23.0-dev.9 → 0.23.0

package/lib/BlockHeadersProvider/createBlockHeadersProviderFromOptions.js

@@ -1,6 +1,6 @@
-const networks = require('@dashevo/dashcore-lib/lib/networks');
 const DAPIClientError = require('../errors/DAPIClientError');
 const BlockHeadersProvider = require('./BlockHeadersProvider');
+const ReconnectableStream = require('../transport/ReconnectableStream');
 
 const validateNumber = (value, name, min = NaN, max = NaN) => {
   if (typeof value !== 'number') {
@@ -11,7 +11,7 @@ const validateNumber = (value, name, min = NaN, max = NaN) => {
     throw new DAPIClientError(`'${name}' can not be less than ${min}`);
   }
 
-  if (!Number.isNaN(max) && value > min) {
+  if (!Number.isNaN(max) && value > max) {
     throw new DAPIClientError(`'${name}' can not be more than ${max}`);
   }
 };
@@ -32,45 +32,60 @@ function createBlockHeadersProviderFromOptions(options, coreMethods) {
     blockHeadersProvider = options.blockHeadersProvider;
   }
 
+  const createContinuousSyncStream = (fromBlockHeight) => ReconnectableStream
+    .create(
+      coreMethods.subscribeToBlockHeadersWithChainLocks,
+      {
+        maxRetriesOnError: -1,
+      },
+    )({
+      fromBlockHeight,
+    });
+
+  const createHistoricalSyncStream = (fromBlockHeight, count) => {
+    const { subscribeToBlockHeadersWithChainLocks } = coreMethods;
+    return subscribeToBlockHeadersWithChainLocks({
+      fromBlockHeight,
+      count,
+    });
+  };
+
   if (options.blockHeadersProviderOptions) {
+    const { network } = options;
+
     const blockHeadersProviderOptions = {
       ...BlockHeadersProvider.defaultOptions,
       ...options.blockHeadersProviderOptions,
+      network,
     };
 
     const {
-      network,
-      autoStart,
       maxParallelStreams,
       targetBatchSize,
       fromBlockHeight,
       maxRetries,
     } = blockHeadersProviderOptions;
 
-    if (network && !networks.get(network)) {
-      throw new DAPIClientError(`Invalid network '${options.network}'`);
-    }
-
-    if (typeof autoStart !== 'boolean') {
-      throw new DAPIClientError('\'autoStart\' option must have boolean type');
-    }
-
     validateNumber(maxParallelStreams, 'maxParallelStreams', 1);
     validateNumber(targetBatchSize, 'targetBatchSize', 1);
     validateNumber(fromBlockHeight, 'fromBlockHeight', 1);
-    validateNumber(maxRetries, 'maxRetries', 0);
+    validateNumber(maxRetries, 'maxRetries', 0, 100);
 
     blockHeadersProvider = new BlockHeadersProvider(
       blockHeadersProviderOptions,
+      createHistoricalSyncStream,
+      createContinuousSyncStream,
     );
   }
 
   if (!blockHeadersProvider) {
-    blockHeadersProvider = new BlockHeadersProvider();
+    blockHeadersProvider = new BlockHeadersProvider(
+      {},
+      createContinuousSyncStream,
+      createHistoricalSyncStream,
+    );
   }
 
-  blockHeadersProvider.setCoreMethods(coreMethods);
-
   return blockHeadersProvider;
 }
 

package/lib/DAPIClient.js

@@ -65,12 +65,6 @@ class DAPIClient extends EventEmitter {
     this.blockHeadersProvider.on(BlockHeadersProvider.EVENTS.ERROR, (e) => {
       this.emit(EVENTS.ERROR, e);
     });
-
-    if (this.options.blockHeadersProviderOptions.autoStart) {
-      this.blockHeadersProvider.start().catch((e) => {
-        this.emit(EVENTS.ERROR, e);
-      });
-    }
   }
 }
 

package/lib/index.js

@@ -1,9 +1,12 @@
 const DAPIClient = require('./DAPIClient');
 
 const NotFoundError = require('./transport/GrpcTransport/errors/NotFoundError');
+const BlockHeadersProvider = require('./BlockHeadersProvider/BlockHeadersProvider');
 
 DAPIClient.Errors = {
   NotFoundError,
 };
 
+DAPIClient.BlockHeadersProvider = BlockHeadersProvider;
+
 module.exports = DAPIClient;

package/lib/networkConfigs.js

@@ -12,156 +12,120 @@ module.exports = {
     // that breaks test suite and application logic. Temporary solution is to hardcode
     // reliable DCG testnet masternodes to connect. Should be removed when PoSe is introduced.
     dapiAddressesWhiteList: [
-      '52.11.85.154',
-      '52.38.248.133',
-      '34.212.231.240',
-      '54.185.249.226',
-      '34.215.57.86',
-      '54.190.73.116',
-      '34.214.2.219',
-      '54.212.84.164',
-      '35.164.96.124',
-      '34.219.81.129',
-      '34.221.42.205',
-      '34.208.88.128',
-      '54.189.162.193',
-      '34.220.124.90',
-      '54.201.242.241',
-      '54.68.10.46',
-      '34.210.81.39',
-      '18.237.47.243',
-      '54.187.229.6',
-      '34.214.102.160',
-      '34.219.93.145',
-      '35.165.37.186',
-      '54.202.157.120',
-      '34.215.144.176',
-      '52.13.119.69',
-      '34.220.12.188',
-      '18.237.5.33',
-      '54.191.32.70',
-      '54.213.219.155',
-      '35.167.25.157',
-      '54.213.89.75',
-      '52.32.232.156',
-      '34.212.226.44',
-      '35.160.140.37',
-      '52.11.133.244',
-      '54.201.189.185',
-      '34.216.200.22',
-      '34.220.144.226',
-      '34.216.195.19',
-      '54.185.1.69',
-      '35.166.29.155',
-      '18.237.147.160',
-      '34.220.228.214',
-      '54.212.75.8',
-      '35.163.152.74',
-      '18.236.78.191',
-      '54.148.106.179',
-      '34.211.46.222',
-      '35.160.13.25',
-      '34.220.17.107',
-      '34.212.65.137',
-      '54.185.249.172',
-      '54.70.65.199',
-      '54.69.210.42',
-      '18.236.160.247',
-      '54.245.197.173',
-      '54.187.11.213',
-      '54.218.70.46',
-      '35.165.207.13',
-      '34.211.49.3',
-      '34.219.36.94',
-      '34.222.127.158',
-      '34.222.242.228',
-      '52.26.220.40',
-      '52.36.244.225',
-      '34.222.225.76',
-      '18.236.169.114',
-      '54.201.236.212',
-      '54.203.241.214',
-      '34.221.254.29',
-      '54.187.50.120',
-      '54.184.140.221',
-      '34.215.192.133',
-      '35.164.180.39',
-      '54.184.183.20',
-      '52.43.197.215',
-      '54.201.42.245',
-      '54.218.113.88',
-      '54.244.141.192',
-      '34.217.98.54',
-      '34.222.168.33',
-      '52.32.143.49',
-      '54.187.224.80',
-      '54.189.87.145',
-      '52.39.164.105',
-      '54.70.55.164',
-      '54.214.68.206',
-      '54.201.239.109',
-      '34.215.146.162',
-      '18.236.233.120',
-      '54.190.217.178',
-      '34.220.41.134',
-      '34.212.178.215',
-      '34.219.169.55',
-      '54.218.251.43',
-      '18.236.216.191',
-      '54.188.17.60',
-      '54.191.227.118',
-      '34.213.5.102',
-      '35.166.79.235',
-      '54.71.107.225',
-      '54.201.162.86',
-      '52.34.141.75',
-      '34.217.43.189',
-      '52.38.77.105',
-      '52.11.252.174',
-      '54.191.221.246',
-      '54.218.107.83',
-      '54.212.18.218',
-      '34.220.53.77',
-      '54.244.41.15',
-      '34.222.135.203',
-      '54.191.110.152',
-      '34.208.190.130',
-      '34.222.6.55',
-      '54.184.7.184',
-      '52.12.47.86',
-      '34.217.28.248',
-      '54.149.252.146',
-      '54.149.80.193',
-      '34.215.55.0',
-      '34.220.74.48',
-      '34.209.124.112',
-      '34.217.23.70',
-      '34.222.102.137',
-      '34.209.166.42',
-      '18.236.128.49',
-      '35.163.99.20',
-      '34.215.67.224',
-      '34.211.244.117',
-      '18.236.199.232',
-      '54.191.237.52',
-      '34.223.226.224',
-      '54.149.133.143',
-      '52.41.198.242',
-      '54.148.215.161',
-      '54.188.193.70',
-      '54.218.104.194',
-      '34.209.73.208',
-      '34.220.88.70',
-      '52.40.101.104',
-      '18.236.68.153',
-      '34.218.76.179',
-      '34.219.94.178',
-      '54.218.127.128',
-      '52.27.198.246',
-      '18.237.204.153',
-      '35.166.57.113',
-      '54.191.15.3',
-      '18.237.128.46',
+      '34.216.69.175',
+      '34.218.75.96',
+      '18.237.220.27',
+      '54.191.38.234',
+      '35.93.95.157',
+      '35.166.240.246',
+      '35.91.186.151',
+      '35.161.123.225',
+      '54.212.169.115',
+      '54.187.168.12',
+      '18.236.191.199',
+      '18.237.165.224',
+      '52.36.42.1',
+      '34.220.32.216',
+      '34.222.238.250',
+      '35.93.34.215',
+      '34.221.10.165',
+      '54.203.241.195',
+      '35.92.138.231',
+      '52.38.169.156',
+      '54.187.21.108',
+      '34.219.48.219',
+      '34.217.38.221',
+      '35.92.157.107',
+      '18.236.82.230',
+      '54.184.225.22',
+      '18.237.144.120',
+      '18.237.254.214',
+      '35.88.29.196',
+      '35.89.126.245',
+      '34.217.148.69',
+      '35.89.193.46',
+      '35.89.119.37',
+      '54.186.161.236',
+      '52.13.63.7',
+      '18.236.233.225',
+      '54.191.138.72',
+      '54.191.59.75',
+      '18.237.160.84',
+      '54.218.236.193',
+      '54.148.178.140',
+      '35.161.168.136',
+      '35.161.33.22',
+      '35.160.130.44',
+      '34.212.104.247',
+      '52.13.29.83',
+      '54.149.39.172',
+      '35.89.93.255',
+      '35.85.46.137',
+      '54.188.154.252',
+      '54.218.11.172',
+      '54.186.47.235',
+      '54.244.145.48',
+      '18.236.232.153',
+      '34.220.226.135',
+      '34.220.30.59',
+      '18.237.160.97',
+      '18.236.146.99',
+      '35.88.169.18',
+      '35.164.17.198',
+      '54.218.80.158',
+      '34.220.102.107',
+      '35.165.60.113',
+      '34.215.234.63',
+      '35.89.146.226',
+      '35.89.86.26',
+      '35.88.160.231',
+      '54.245.8.155',
+      '52.36.221.94',
+      '52.35.46.188',
+      '34.221.153.67',
+      '54.212.153.15',
+      '35.85.55.192',
+      '35.89.105.90',
+      '52.24.22.52',
+      '54.212.33.96',
+      '52.10.19.238',
+      '35.160.190.165',
+      '34.219.3.61',
+      '54.187.32.187',
+      '35.162.221.77',
+      '35.91.64.183',
+      '18.236.189.15',
+      '35.91.145.195',
+      '54.186.251.30',
+      '54.245.9.46',
+      '35.91.48.128',
+      '54.244.75.85',
+      '34.221.159.53',
+      '35.89.88.166',
+      '54.185.249.165',
+      '54.245.9.209',
+      '34.222.167.162',
+      '54.191.88.232',
+      '54.191.111.112',
+      '18.237.146.37',
+      '35.89.148.27',
+      '35.91.8.48',
+      '18.236.208.138',
+      '54.213.60.60',
+      '35.92.151.94',
+      '18.237.241.37',
+      '54.202.209.229',
+      '34.221.9.70',
+      '35.89.38.62',
+      '54.218.81.193',
+      '34.221.158.21',
+      '35.88.97.57',
+      '54.68.247.40',
+      '35.88.168.176',
+      '35.89.202.171',
+      '34.220.106.205',
+      '34.210.86.23',
+      '44.230.40.184',
     ],
   },
   evonet: {

package/lib/test/bootstrap.js

@@ -20,4 +20,10 @@ afterEach(function afterEach() {
   this.sinon.restore();
 });
 
+before(function before() {
+  if (!this.sinon) {
+    this.sinon = sinon.createSandbox();
+  }
+});
+
 global.expect = expect;

package/lib/test/mocks/BlockHeadersWithChainLocksStreamMock.js

@@ -0,0 +1,53 @@
+const EventEmitter = require('events');
+
+class BlockHeadersWithChainLocksStreamMock extends EventEmitter {
+  constructor(sinon) {
+    super();
+
+    sinon.spy(this, 'on');
+    sinon.spy(this, 'removeListener');
+    sinon.spy(this, 'emit');
+    sinon.spy(this, 'destroy');
+    sinon.spy(this, 'removeAllListeners');
+    sinon.spy(this, 'cancel');
+
+    this.errored = false;
+  }
+
+  destroy(e) {
+    this.emit('end');
+    if (e) {
+      this.emit('error', e);
+    }
+  }
+
+  cancel() {
+    if (!this.errored) {
+      const err = new Error('CANCELED_ON_CLIENT');
+      err.code = 1;
+      this.emit('error', err);
+    }
+  }
+
+  emit(event, data) {
+    if (event === 'error') {
+      this.errored = true;
+    }
+    super.emit(event, data);
+  }
+
+  /**
+   * @param headers {BlockHeader[]}
+   */
+  sendHeaders(headers) {
+    this.emit('data', {
+      getBlockHeaders: () => ({
+        getHeadersList() {
+          return headers.map((header) => header.toBuffer());
+        },
+      }),
+    });
+  }
+}
+
+module.exports = BlockHeadersWithChainLocksStreamMock;

package/lib/test/mocks/mockHeadersChain.js

@@ -0,0 +1,55 @@
+const X11 = require('wasm-x11-hash');
+const { BlockHeader, configure } = require('@dashevo/dashcore-lib');
+const { genesis } = require('@dashevo/dash-spv');
+
+const getRoot = (network) => {
+  switch (network) {
+    case 'testnet':
+      return genesis.getTestnetGenesis();
+    case 'devnet':
+      return genesis.getDevnetGenesis();
+    case 'regtest':
+      return genesis.getRegtestGenesis();
+    default:
+      break;
+  }
+
+  return null;
+};
+
+const BLOCK_TIME = 2.5 * 60;
+
+let x11;
+
+const mockHeadersChain = async (network, length, root) => {
+  if (!x11) {
+    x11 = await X11();
+    // Configure Dashcore lib to operate with wasm x11
+    configure({
+      x11hash: x11,
+    });
+  }
+
+  const rootHeader = root || getRoot(network);
+
+  const chain = [rootHeader];
+
+  let prevHeader = rootHeader;
+  for (let i = 0; i < length - 1; i += 1) {
+    const header = new BlockHeader({
+      version: prevHeader.version,
+      prevHash: Buffer.from(prevHeader.hash, 'hex').reverse(),
+      merkleRoot: Buffer.alloc(32),
+      time: prevHeader.time + BLOCK_TIME,
+      bits: prevHeader.bits,
+      nonce: 3861367235,
+    });
+
+    chain.push(header);
+    prevHeader = header;
+  }
+
+  return chain;
+};
+
+module.exports = mockHeadersChain;

package/lib/transport/GrpcTransport/createGrpcTransportError.js

@@ -50,32 +50,34 @@ function createGrpcTransportError(grpcError, dapiAddress) {
 
   const message = grpcError.details || grpcError.message;
 
+  let metadata = {};
+
   if (grpcError.metadata) {
     // In cases of gRPC-Web client we get plain map instead of Metadata instance
-    let metadataMap = grpcError.metadata;
+    metadata = grpcError.metadata;
     if (grpcError.metadata instanceof Metadata) {
-      metadataMap = grpcError.metadata.getMap();
+      metadata = grpcError.metadata.getMap();
     }
+  }
 
-    // Error data
-    const driveErrorData = metadataMap['drive-error-data-bin'];
-    if (driveErrorData) {
-      const encodedData = Buffer.from(driveErrorData, 'base64');
-      data = cbor.decode(encodedData);
-    }
+  // Error data
+  const driveErrorData = metadata['drive-error-data-bin'];
+  if (driveErrorData) {
+    const encodedData = Buffer.from(driveErrorData, 'base64');
+    data = cbor.decode(encodedData);
+  }
 
-    // Error code
-    const driveErrorCode = metadataMap.code;
-    if (driveErrorCode) {
-      code = Number(driveErrorCode);
-    }
+  // Error code
+  const driveErrorCode = metadata.code;
+  if (driveErrorCode) {
+    code = Number(driveErrorCode);
+  }
 
-    // Error stack
-    const driveErrorStack = metadataMap['stack-bin'];
-    if (driveErrorStack) {
-      const encodedStack = Buffer.from(driveErrorStack, 'base64');
-      data.stack = cbor.decode(encodedStack);
-    }
+  // Error stack
+  const driveErrorStack = metadata['stack-bin'];
+  if (driveErrorStack) {
+    const encodedStack = Buffer.from(driveErrorStack, 'base64');
+    data.stack = cbor.decode(encodedStack);
   }
 
   // Specialized classes
@@ -100,13 +102,6 @@ function createGrpcTransportError(grpcError, dapiAddress) {
   }
 
   if (code === GrpcErrorCodes.INTERNAL) {
-    if (grpcError.metadata) {
-      const metaStack = grpcError.metadata.get('stack-bin');
-      if (metaStack && metaStack.length > 0) {
-        data.stack = cbor.decode(metaStack[0]);
-      }
-    }
-
     return new InternalServerError(
       code,
       message,