@dashevo/dapi-client 0.24.0-dev.6 → 0.25.0-dev.2

package/lib/test/fixtures/getMetadataFixture.js

@@ -1,10 +1,18 @@
 /**
- * @returns {{coreChainLockedHeight: number, height: number}}
+ * @returns {{
+ * coreChainLockedHeight: number,
+ * height: number,
+ * signature: Buffer,
+ * protocolVersion: number,
+ * timeMs: number,
+ * }}
  */
 function getMetadataFixture() {
   return {
     height: 10,
     coreChainLockedHeight: 42,
+    timeMs: new Date().getTime(),
+    protocolVersion: 1,
   };
 }
 

package/lib/test/fixtures/getProofFixture.js

@@ -2,14 +2,15 @@
  * @returns {{
  *   merkleProof: Buffer,
  *   signature: Buffer,
- *   signatureLLMQHash: Buffer
+ *   quorumHash: Buffer
  * }}
  */
 function getProofFixture() {
   return {
-    signatureLLMQHash: Buffer.from('AQEBAQEBAQEBAQEB', 'base64'),
+    quorumHash: Buffer.from('AQEBAQEBAQEBAQEB', 'base64'),
     signature: Buffer.from('AgICAgICAgICAgIC', 'base64'),
     merkleProof: Buffer.from('0100000001f0faf5f55674905a68eba1be2f946e667c1cb5010101', 'hex'),
+    round: 42,
   };
 }
 

package/lib/test/mocks/BlockHeadersWithChainLocksStreamMock.js

@@ -0,0 +1,54 @@
+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, 'removeAllListeners');
+    sinon.spy(this, 'cancel');
+
+    this.errored = false;
+  }
+
+  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());
+        },
+      }),
+    });
+  }
+
+  errorHandler(e) {
+    this.emit('error', e);
+  }
+
+  end() {
+    this.emit('end');
+    this.removeAllListeners();
+  }
+}
+
+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/GrpcTransport.js

@@ -83,7 +83,7 @@ class GrpcTransport {
         throw error;
       }
 
-      const responseError = this.createGrpcTransportError(error, address);
+      const responseError = await this.createGrpcTransportError(error, address);
 
       if (!(responseError instanceof RetriableResponseError)) {
         throw responseError;
@@ -133,20 +133,15 @@ class GrpcTransport {
    */
   makeGrpcUrlFromAddress(address) {
     let protocol = address.getProtocol();
-    let port = address.getHttpPort();
-
     // For NodeJS Client
     if (typeof process !== 'undefined'
       && process.versions != null
-      && process.versions.node != null) {
-      port = address.getGrpcPort();
-
-      if (address.isSelfSignedCertificateAllowed()) {
-        protocol = 'http';
-      }
+      && process.versions.node != null
+      && address.isSelfSignedCertificateAllowed()) {
+      protocol = 'http';
     }
 
-    return `${protocol}://${address.getHost()}:${port}`;
+    return `${protocol}://${address.getHost()}:${address.getPort()}`;
   }
 }
 

package/lib/transport/GrpcTransport/createGrpcTransportError.js

@@ -1,9 +1,12 @@
 const cbor = require('cbor');
 
-const createConsensusError = require('@dashevo/dpp/lib/errors/consensus/createConsensusError');
 const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
-const { Metadata } = require('@grpc/grpc-js/build/src/metadata');
+const { parseMetadata } = require('@dashevo/dapi-grpc');
 
+const {
+  deserializeConsensusError,
+} = require('@dashevo/wasm-dpp');
+const { default: loadWasmDpp } = require('@dashevo/wasm-dpp');
 const NotFoundError = require('./errors/NotFoundError');
 const TimeoutError = require('./errors/TimeoutError');
 const ResponseError = require('../errors/response/ResponseError');
@@ -43,22 +46,16 @@ const errorClasses = {
  * @param {DAPIAddress} dapiAddress
  * @returns {ResponseError}
  */
-function createGrpcTransportError(grpcError, dapiAddress) {
+async function createGrpcTransportError(grpcError, dapiAddress) {
+  await loadWasmDpp();
+
   // Extract error code and data
   let data = {};
   let { code } = grpcError;
 
   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
-    metadata = grpcError.metadata;
-    if (grpcError.metadata instanceof Metadata) {
-      metadata = grpcError.metadata.getMap();
-    }
-  }
+  const metadata = parseMetadata(grpcError.metadata) || {};
 
   // Error data
   const driveErrorData = metadata['drive-error-data-bin'];
@@ -122,9 +119,9 @@ function createGrpcTransportError(grpcError, dapiAddress) {
 
   // DPP consensus errors
   if (code >= 1000 && code < 5000) {
-    const consensusError = createConsensusError(code, data.arguments || []);
+    const consensusError = deserializeConsensusError(data.serializedError || []);
 
-    delete data.arguments;
+    delete data.serializedError;
 
     return new InvalidRequestDPPError(consensusError, data, dapiAddress);
   }

package/lib/transport/JsonRpcTransport/JsonRpcTransport.js

@@ -67,7 +67,7 @@ class JsonRpcTransport {
       const result = await this.requestJsonRpc(
         address.getProtocol(),
         address.getHost(),
-        address.getHttpPort(),
+        address.getPort(),
         address.isSelfSignedCertificateAllowed(),
         method,
         params,

package/lib/transport/JsonRpcTransport/requestJsonRpc.js

@@ -1,6 +1,4 @@
-const axios = require('axios');
 const https = require('https');
-
 const JsonRpcError = require('./errors/JsonRpcError');
 const WrongHttpCodeError = require('./errors/WrongHttpCodeError');
 
@@ -25,11 +23,6 @@ async function requestJsonRpc(protocol, host, port, selfSigned, method, params,
     id: 1,
   };
 
-  const postOptions = {};
-  if (options.timeout !== undefined) {
-    postOptions.timeout = options.timeout;
-  }
-
   const requestInfo = {
     protocol,
     host,
@@ -40,40 +33,44 @@ async function requestJsonRpc(protocol, host, port, selfSigned, method, params,
     options,
   };
 
-  let response;
+  const requestOptions = {
+    method: 'POST',
+    body: JSON.stringify(payload),
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  };
+
+  let requestTimeoutId;
+  if (options.timeout) {
+    const controller = new AbortController();
+    requestTimeoutId = setTimeout(() => controller.abort(), options.timeout);
+    Object.assign(requestOptions, { signal: controller.signal });
+  }
 
-  const config = { timeout: options.timeout };
   // For NodeJS Client
   if (typeof process !== 'undefined'
     && process.versions != null
     && process.versions.node != null
     && protocol === 'https'
     && selfSigned) {
-    config.httpsAgent = new https.Agent({
+    requestOptions.agent = new https.Agent({
       rejectUnauthorized: false,
     });
   }
 
-  try {
-    response = await axios.post(
-      url,
-      payload,
-      config,
-    );
-  } catch (error) {
-    if (error.response && error.response.status >= 500) {
-      throw new WrongHttpCodeError(requestInfo, error.response.status, error.response.statusText);
-    }
+  // eslint-disable-next-line
+  const response = await fetch(url, requestOptions);
 
-    throw error;
+  if (typeof requestTimeoutId !== 'undefined') {
+    clearTimeout(requestTimeoutId);
   }
+  const data = await response.json();
 
-  if (response.status !== 200) {
-    throw new WrongHttpCodeError(requestInfo, response.status, response.statusMessage);
+  if (!response.ok) {
+    throw new WrongHttpCodeError(requestInfo, response.status, response.statusText);
   }
 
-  const { data } = response;
-
   if (data.error) {
     throw new JsonRpcError(requestInfo, data.error);
   }

package/lib/transport/ReconnectableStream.js

@@ -0,0 +1,284 @@
+const EventEmitter = require('events');
+const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
+const wait = require('../utils/wait');
+
+/**
+ * @typedef ReconnectableStreamOptions
+ * @property {number} [autoReconnectInterval]
+ *    interval in MS to perform auto reconnect
+ * @property {number} [maxRetriesOnError]
+ *    maximum amount of retry attempts on error happens. If set to -1, retries are infinite
+ * @property {number} [retryOnErrorDelay]
+ *    delay in MS to perform retry after an error
+ */
+const defaultOptions = {
+  // TODO: manage timeout according to the Nginx setting of the node
+  autoReconnectInterval: 50000,
+  maxRetriesOnError: 10,
+  retryOnErrorDelay: 1000,
+};
+
+const EVENTS = {
+  DATA: 'data',
+  ERROR: 'error',
+  END: 'end',
+  BEFORE_RECONNECT: 'beforeReconnect',
+};
+
+/**
+ * A wrapper around grpc-js/grpc-web streams that provides auto-reconnect
+ * and retry on error functionality
+ * - Auto reconnect is needed to not hang on one node for too long.
+ *   It happens within provided interval
+ * - Retry on error logic performs retry attempts until it reaches it's limit.
+ *   After reaching limit, ReconnectableStream emits an error.
+ */
+class ReconnectableStream extends EventEmitter {
+  /**
+   * Helper that wraps stream creation function and performs auto connection
+   *
+   * @param {Function} createStreamFunction - function returning grpc-js/grpc-web stream
+   * @param {ReconnectableStreamOptions} options
+   * @returns {function(...[*]): Promise<ReconnectableStream>}
+   */
+  static create(createStreamFunction, options) {
+    return async (...args) => {
+      const reconnectableStream = new ReconnectableStream(createStreamFunction, options);
+      await reconnectableStream.connect(...args);
+      return reconnectableStream;
+    };
+  }
+
+  /**
+   * @param {Function} createStream - function returning grpc-js/grpc-web stream
+   * @param {ReconnectableStreamOptions} options
+   */
+  constructor(createStream, options = {}) {
+    super();
+
+    const opts = { ...defaultOptions, ...options };
+
+    /**
+     * Auto-reconnect interval in millisecond
+     * It is needed to automatically reconnect to another DAPI node
+     *
+     * @type {number}
+     */
+    this.autoReconnectInterval = opts.autoReconnectInterval;
+    this.retryOnErrorDelay = opts.retryOnErrorDelay;
+
+    /**
+     * Max amount of retries on error
+     */
+    this.maxRetriesOnError = opts.maxRetriesOnError;
+
+    /**
+     * Current amount of retries on error
+     * (Does not have effect if maxRetriesOnError === -1)
+     */
+    this.retriesOnError = 0;
+
+    /**
+     * createStream arguments
+     */
+    this.args = null;
+    /**
+     * grpc stream
+     */
+    this.stream = null;
+
+    /**
+     * Function to wrap around to handle interval reconnects and error retries
+     */
+    this.createStream = createStream;
+
+    /**
+     * Reference to setTimeout managed by autoReconnectInterval
+     */
+    this.reconnectTimeout = null;
+
+    // For mocks
+    this.setTimeout = (callback, delay) => setTimeout(callback, delay);
+    this.clearTimeout = (reference) => clearTimeout(reference);
+
+    this.connect = this.connect.bind(this);
+    this.reconnect = this.reconnect.bind(this);
+    this.cancel = this.cancel.bind(this);
+    this.errorHandler = this.errorHandler.bind(this);
+    this.dataHandler = this.dataHandler.bind(this);
+    this.endHandler = this.endHandler.bind(this);
+    this.addListeners = this.addListeners.bind(this);
+  }
+
+  async connect(...args) {
+    // Memorize current stream args (which can be altered by beforeReconnect logic)
+    this.args = args;
+
+    // Create grpc stream
+    this.stream = await this.createStream(...this.args);
+
+    // Add event listeners
+    this.addListeners();
+
+    if (this.autoReconnectInterval > 0) {
+      this.startAutoReconnect();
+    }
+  }
+
+  startAutoReconnect() {
+    if (this.reconnectTimeout) {
+      throw new Error('Auto reconnect timeout is already running.');
+    }
+    this.reconnectTimeout = this.setTimeout(
+      this.reconnect,
+      this.autoReconnectInterval,
+    );
+  }
+
+  reconnect() {
+    if (this.reconnectTimeout) {
+      this.reconnectTimeout = null;
+      this.stream.cancel();
+
+      let newArgs = this.args || [];
+      const updateArgs = (...args) => {
+        newArgs = args;
+      };
+
+      this.emit(EVENTS.BEFORE_RECONNECT, updateArgs);
+      this.connect(...newArgs)
+        .catch((connectError) => this.emit(EVENTS.ERROR, connectError));
+    }
+  }
+
+  /**
+   * Function that adds EventEmitter style listeners
+   * to the stream and also rewires stream cancel function
+   * in order to automatically unsubscribe from events
+   *
+   * @private
+   */
+  addListeners() {
+    this.stream.on(EVENTS.DATA, this.dataHandler);
+    this.stream.on(EVENTS.ERROR, this.errorHandler);
+    this.stream.on(EVENTS.END, this.endHandler);
+
+    const { cancel } = this.stream;
+
+    // Rewire cancel function in order to
+    // unsubscribe from DATA and END events.
+    // We don't unsubscribe from ERROR event because it
+    // handles `CANCELLED_ON_CLIENT` error after calling .cancel() and must stay
+    this.stream.cancel = () => {
+      this.stream.removeListener(EVENTS.DATA, this.dataHandler);
+      this.stream.removeListener(EVENTS.END, this.endHandler);
+      cancel.call(this.stream);
+    };
+  }
+
+  /**
+   * stream.on('data') handler
+   *
+   * @param data
+   */
+  dataHandler(data) {
+    this.emit(EVENTS.DATA, data);
+  }
+
+  /**
+   * stream.on('end') handler
+   *
+   * @private
+   */
+  endHandler() {
+    this.stopAutoReconnect();
+    this.stream = null;
+    this.emit(EVENTS.END);
+  }
+
+  /**
+   * stream.on('error') handler
+   *
+   * @private
+   * @param e
+   */
+  errorHandler(e) {
+    // In case of cancellation nothing has to happen.
+    // TODO: do we need to propagate GrpcErrorCodes.CANCELLED further?
+    if (e.code === GrpcErrorCodes.CANCELLED) {
+      return;
+    }
+
+    // Retry stream
+    this.retryOnError(e);
+  }
+
+  /**
+   * Manages retry logic
+   *
+   * @param e
+   */
+  retryOnError(e) {
+    // Stop reconnect timeout if there is one
+    this.stopAutoReconnect();
+
+    // Unsubscribe from events in case of the external call
+    this.stream.removeListener(EVENTS.END, this.endHandler);
+    this.stream.removeListener(EVENTS.DATA, this.dataHandler);
+
+    const canRetry = this.maxRetriesOnError === -1 // Infinite retries
+      || this.retriesOnError < this.maxRetriesOnError; // Or less than max limit
+
+    if (canRetry) {
+      // Handle 'beforeReconnect` logic
+      let newArgs = this.args || [];
+      const updateArgsBeforeReconnect = (...args) => {
+        newArgs = args;
+      };
+
+      // Emit beforeReconnect event in case parent would want to alter arguments
+      this.emit(EVENTS.BEFORE_RECONNECT, updateArgsBeforeReconnect);
+
+      // Wait before reconnecting
+      wait(this.retryOnErrorDelay)
+        .then(() => this.connect(...newArgs))// Reconnect with new args
+        .then(() => {
+          this.retriesOnError += 1; // Increase amount of current retries
+        })
+        .catch((connectError) => {
+          this.emit(EVENTS.ERROR, connectError); // Or emit error in case retry has failed
+        });
+    } else {
+      // Or simply emit error in case retry attempts were exhausted
+      this.emit(EVENTS.ERROR, e);
+    }
+  }
+
+  /**
+   * Stops auto reconnect timeout
+   *
+   * @private
+   */
+  stopAutoReconnect() {
+    if (this.reconnectTimeout) {
+      this.clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+
+  /**
+   * Cancels stream.
+   * Returns `stream.cancel()` to handle it from parent if needed.
+   * (grpc-js cancel() is asynchronous and grpc-web is synchronous)
+   *
+   * @returns {*}
+   */
+  cancel() {
+    this.stopAutoReconnect();
+    return this.stream.cancel();
+  }
+}
+
+ReconnectableStream.EVENTS = EVENTS;
+
+module.exports = ReconnectableStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "0.24.0-dev.6",
+  "version": "0.25.0-dev.2",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,17 +26,18 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "0.24.0-dev.6",
-    "@dashevo/dash-spv": "0.24.0-dev.6",
-    "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dpp": "0.24.0-dev.6",
-    "@dashevo/grpc-common": "0.24.0-dev.6",
-    "@grpc/grpc-js": "^1.3.7",
-    "axios": "^0.27.2",
+    "@dashevo/dapi-grpc": "0.25.0-dev.2",
+    "@dashevo/dash-spv": "0.25.0-dev.2",
+    "@dashevo/dashcore-lib": "~0.20.3",
+    "@dashevo/dpp": "0.25.0-dev.2",
+    "@dashevo/grpc-common": "0.25.0-dev.2",
+    "@dashevo/wasm-dpp": "0.25.0-dev.2",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
-    "lodash.sample": "^4.2.1",
-    "node-inspect-extracted": "^1.0.8"
+    "lodash": "^4.17.21",
+    "node-fetch": "^2.6.7",
+    "node-inspect-extracted": "^1.0.8",
+    "wasm-x11-hash": "~0.0.2"
   },
   "devDependencies": {
     "@babel/core": "^7.15.5",
@@ -54,6 +55,7 @@
     "eslint-plugin-import": "^2.24.2",
     "eslint-plugin-jsdoc": "^27.0.0",
     "events": "^3.3.0",
+    "google-protobuf": "^3.12.2",
     "karma": "^6.4.1",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
@@ -71,12 +73,13 @@
     "string_decoder": "^1.3.0",
     "url": "^0.11.0",
     "util": "^0.12.4",
-    "webpack": "^5.59.1",
+    "webpack": "^5.76.1",
     "webpack-cli": "^4.9.1"
   },
   "files": [
     "docs",
-    "lib"
+    "lib",
+    "polyfills"
   ],
   "scripts": {
     "build:web": "webpack",

package/polyfills/fetch-polyfill.js

@@ -0,0 +1,10 @@
+/* eslint-disable */
+
+const { default: fetch, Headers, Request, Response } = require('node-fetch');
+
+if (!globalThis.fetch) {
+  globalThis.fetch = fetch;
+  globalThis.Headers = Headers;
+  globalThis.Request = Request;
+  globalThis.Response = Response;
+}