@dashevo/dapi-client 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/lib/BlockHeadersProvider/BlockHeadersProvider.js

@@ -1,6 +1,4 @@
 const EventEmitter = require('events');
-const { configure: configureDashcore } = require('@dashevo/dashcore-lib');
-const X11 = require('wasm-x11-hash');
 const { SpvChain, SPVError } = require('@dashevo/dash-spv');
 
 const BlockHeadersReader = require('./BlockHeadersReader');
@@ -51,7 +49,6 @@ class BlockHeadersProvider extends EventEmitter {
     this.spvChain = new SpvChain(this.options.network, 100);
 
     this.state = STATES.IDLE;
-    this.wasmX11Ready = false;
 
     this.errorHandler = this.errorHandler.bind(this);
     this.headersHandler = this.headersHandler.bind(this);
@@ -79,13 +76,7 @@ class BlockHeadersProvider extends EventEmitter {
    * @private
    */
   async init() {
-    if (!this.wasmX11Ready) {
-      const x11Hash = await X11();
-      configureDashcore({
-        x11hash: x11Hash,
-      });
-      this.wasmX11Ready = true;
-    }
+    await SpvChain.wasmX11Ready();
 
     if (!this.blockHeadersReader) {
       this.blockHeadersReader = new BlockHeadersReader(
@@ -113,12 +104,18 @@ class BlockHeadersProvider extends EventEmitter {
    * Initializes SPV chain with a list of headers and a known lastSyncedHeaderHeight
    *
    * @param headers
-   * @param lastSyncedHeaderHeight
+   * @param firstHeaderHeight
    */
-  initializeWith(headers, lastSyncedHeaderHeight) {
-    const firstHeaderHeight = lastSyncedHeaderHeight - headers.length + 1;
-    this.spvChain.reset(firstHeaderHeight);
-    this.spvChain.addHeaders(headers, firstHeaderHeight);
+  async initializeChainWith(headers, firstHeaderHeight) {
+    await SpvChain.wasmX11Ready();
+
+    if (headers.length === 0) {
+      // If there are no headers, initialize chain from genesis
+      this.spvChain.initialize();
+    } else {
+      this.spvChain.initialize(headers[0], firstHeaderHeight);
+      this.spvChain.addHeaders(headers);
+    }
   }
 
   /**
@@ -130,7 +127,8 @@ class BlockHeadersProvider extends EventEmitter {
   ensureChainRoot(height) {
     // Flush spv chain in case header at specified height was not found
     if (!this.spvChain.hashesByHeight.has(height - 1)) {
-      this.spvChain.reset(height);
+      this.spvChain.reset();
+      this.spvChain.pendingStartBlockHeight = height;
     }
   }
 

package/lib/DAPIClient.js

@@ -14,6 +14,8 @@ const createJsonTransportError = require('./transport/JsonRpcTransport/createJso
 const BlockHeadersProvider = require('./BlockHeadersProvider/BlockHeadersProvider');
 const createBlockHeadersProviderFromOptions = require('./BlockHeadersProvider/createBlockHeadersProviderFromOptions');
 
+const logger = require('./logger');
+
 const EVENTS = {
   ERROR: 'error',
 };
@@ -30,6 +32,9 @@ class DAPIClient extends EventEmitter {
       timeout: 10000,
       retries: 5,
       blockHeadersProviderOptions: BlockHeadersProvider.defaultOptions,
+      loggerOptions: {
+        identifier: '',
+      },
       ...options,
     };
 
@@ -52,6 +57,7 @@ class DAPIClient extends EventEmitter {
 
     this.core = new CoreMethodsFacade(jsonRpcTransport, grpcTransport);
     this.platform = new PlatformMethodsFacade(grpcTransport);
+    this.logger = logger.getForId(this.options.loggerOptions.identifier);
 
     this.initBlockHeadersProvider();
   }
@@ -81,6 +87,8 @@ DAPIClient.EVENTS = EVENTS;
  * @property {number} [retries=3]
  * @property {number} [baseBanTime=60000]
  * @property {boolean} [throwDeadlineExceeded]
+ * @property {object} [loggerOptions]
+ * @property {string} [loggerOptions.identifier]
  * @property {BlockHeadersProvider} [blockHeadersProvider]
  * @property {BlockHeadersProviderOptions} [blockHeadersProviderOptions]
  */

package/lib/logger/index.js

@@ -0,0 +1,76 @@
+const util = require('util');
+const winston = require('winston');
+
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+const LOG_TO_FILE = process.env.LOG_WALLET_TO_FILE || 'false';
+
+// Log levels:
+//   error    0
+//   warn     1
+//   info     2  (default)
+//   verbose  3
+//   debug    4
+//   silly    5
+
+const loggers = {};
+
+const createLogger = (formats = [], id = '') => {
+  const format = winston.format.combine(
+    {
+      transform: (info) => {
+        const args = info[Symbol.for('splat')];
+        const result = { ...info };
+        if (args) {
+          result.message = util.format(info.message, ...args);
+        }
+        return result;
+      },
+    },
+    ...formats,
+    winston.format.colorize(),
+    winston.format.printf(({
+      level, message,
+    }) => `${level}: ${message}`),
+  );
+
+  const transports = [
+    new winston.transports.Console({
+      format,
+    }),
+  ];
+
+  if (LOG_TO_FILE === 'true' && typeof window === 'undefined') {
+    transports.push(
+      new winston.transports.File({
+        filename: `wallet${id !== '' ? `_${id}` : ''}`,
+        format,
+      }),
+    );
+  }
+
+  return winston.createLogger({
+    level: LOG_LEVEL,
+    transports,
+  });
+};
+
+const logger = createLogger();
+
+logger.getForId = (id) => {
+  if (!loggers[id]) {
+    const format = {
+      transform: (info) => {
+        const message = `[DAPIClient: ${id}] ${info.message}`;
+        return { ...info, message };
+      },
+    };
+
+    loggers[id] = createLogger([format], id);
+  }
+
+  return loggers[id];
+};
+
+logger.verbose(`Logger uses "${LOG_LEVEL}" level`, { level: LOG_LEVEL });
+
+module.exports = logger;

package/lib/methods/platform/PlatformMethodsFacade.js

@@ -1,10 +1,14 @@
 const broadcastStateTransitionFactory = require('./broadcastStateTransition/broadcastStateTransitionFactory');
 const getDataContractFactory = require('./getDataContract/getDataContractFactory');
+const getDataContractHistoryFactory = require('./getDataContractHistory/getDataContractHistoryFactory');
 const getDocumentsFactory = require('./getDocuments/getDocumentsFactory');
 const getIdentityFactory = require('./getIdentity/getIdentityFactory');
 const getIdentitiesByPublicKeyHashesFactory = require('./getIdentitiesByPublicKeyHashes/getIdentitiesByPublicKeyHashesFactory');
 const waitForStateTransitionResultFactory = require('./waitForStateTransitionResult/waitForStateTransitionResultFactory');
 const getConsensusParamsFactory = require('./getConsensusParams/getConsensusParamsFactory');
+const getEpochsInfoFactory = require('./getEpochsInfo/getEpochsInfoFactory');
+const getProtocolVersionUpgradeVoteStatusFactory = require('./getProtocolVersionUpgradeVoteStatus/getProtocolVersionUpgradeVoteStatusFactory');
+const getProtocolVersionUpgradeStateFactory = require('./getProtocolVersionUpgradeState/getProtocolVersionUpgradeStateFactory');
 
 class PlatformMethodsFacade {
   /**
@@ -13,11 +17,17 @@ class PlatformMethodsFacade {
   constructor(grpcTransport) {
     this.broadcastStateTransition = broadcastStateTransitionFactory(grpcTransport);
     this.getDataContract = getDataContractFactory(grpcTransport);
+    this.getDataContractHistory = getDataContractHistoryFactory(grpcTransport);
     this.getDocuments = getDocumentsFactory(grpcTransport);
     this.getIdentity = getIdentityFactory(grpcTransport);
     this.getIdentitiesByPublicKeyHashes = getIdentitiesByPublicKeyHashesFactory(grpcTransport);
     this.waitForStateTransitionResult = waitForStateTransitionResultFactory(grpcTransport);
     this.getConsensusParams = getConsensusParamsFactory(grpcTransport);
+    this.getEpochsInfo = getEpochsInfoFactory(grpcTransport);
+    this.getProtocolVersionUpgradeVoteStatus = getProtocolVersionUpgradeVoteStatusFactory(
+      grpcTransport,
+    );
+    this.getProtocolVersionUpgradeState = getProtocolVersionUpgradeStateFactory(grpcTransport);
   }
 }
 

package/lib/methods/platform/getConsensusParams/getConsensusParamsFactory.js

@@ -7,6 +7,10 @@ const {
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
 const GetConsensusParamsResponse = require('./getConsensusParamsResponse');
 
+const {
+  GetConsensusParamsRequestV0,
+} = GetConsensusParamsRequest;
+
 /**
  * @param {GrpcTransport} grpcTransport
  * @returns {getConsensusParams}
@@ -22,11 +26,15 @@ function getConsensusParamsFactory(grpcTransport) {
    */
   async function getConsensusParams(height = undefined, options = {}) {
     const getConsensusParamsRequest = new GetConsensusParamsRequest();
+    getConsensusParamsRequest.setV0(
+      new GetConsensusParamsRequestV0(),
+    );
+
     if (height !== undefined) {
-      getConsensusParamsRequest.setHeight(height);
+      getConsensusParamsRequest.getV0().setHeight(height);
     }
 
-    getConsensusParamsRequest.setProve(!!options.prove);
+    getConsensusParamsRequest.getV0().setProve(!!options.prove);
 
     let lastError;
 

package/lib/methods/platform/getConsensusParams/getConsensusParamsResponse.js

@@ -32,8 +32,8 @@ class GetConsensusParamsResponse {
    * @returns {GetConsensusParamsResponse}
    */
   static createFromProto(proto) {
-    const protoBlock = proto.getBlock();
-    const protoEvidence = proto.getEvidence();
+    const protoBlock = proto.getV0().getBlock();
+    const protoEvidence = proto.getV0().getEvidence();
 
     if (!protoBlock && !protoEvidence) {
       throw new InvalidResponseError('Consensus params are not defined');

package/lib/methods/platform/getDataContract/GetDataContractResponse.js

@@ -25,7 +25,7 @@ class GetDataContractResponse extends AbstractResponse {
    * @returns {GetDataContractResponse}
    */
   static createFromProto(proto) {
-    const dataContract = proto.getDataContract();
+    const dataContract = proto.getV0().getDataContract();
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     if (!dataContract && !proof) {

package/lib/methods/platform/getDataContract/getDataContractFactory.js

@@ -22,6 +22,7 @@ function getDataContractFactory(grpcTransport) {
    * @returns {Promise<GetDataContractResponse>}
    */
   async function getDataContract(contractId, options = {}) {
+    const { GetDataContractRequestV0 } = GetDataContractRequest;
     const getDataContractRequest = new GetDataContractRequest();
 
     // need to convert objects inherited from Buffer to pure buffer as google protobuf
@@ -32,8 +33,11 @@ function getDataContractFactory(grpcTransport) {
       contractId = Buffer.from(contractId);
     }
 
-    getDataContractRequest.setId(contractId);
-    getDataContractRequest.setProve(!!options.prove);
+    getDataContractRequest.setV0(
+      new GetDataContractRequestV0()
+        .setId(contractId)
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

package/lib/methods/platform/getDataContractHistory/GetDataContractHistoryResponse.js

@@ -0,0 +1,55 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetDataContractHistoryResponse extends AbstractResponse {
+  /**
+   * @param {object.<number, Buffer>} dataContractHistory
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(dataContractHistory, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.dataContractHistory = dataContractHistory;
+  }
+
+  /**
+   * @returns {object.<number, Buffer>}
+   */
+  getDataContractHistory() {
+    return this.dataContractHistory;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetDataContractHistoryResponse}
+   */
+  static createFromProto(proto) {
+    // History is something that we need to call a method to get a list of entries on
+    const dataContractHistory = proto.getV0().getDataContractHistory();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
+
+    if (!dataContractHistory && !proof) {
+      throw new InvalidResponseError('DataContract is not defined');
+    }
+
+    const history = {};
+
+    if (dataContractHistory) {
+      const dataContractHistoryEntries = dataContractHistory.getDataContractEntriesList();
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const historyEntry of dataContractHistoryEntries) {
+        history[historyEntry.getDate()] = historyEntry.getValue();
+      }
+    }
+
+    return new GetDataContractHistoryResponse(
+      history,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetDataContractHistoryResponse;

package/lib/methods/platform/getDataContractHistory/getDataContractHistoryFactory.js

@@ -0,0 +1,86 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetDataContractHistoryRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const { UInt32Value } = require('google-protobuf/google/protobuf/wrappers_pb');
+
+const GetDataContractHistoryResponse = require('./GetDataContractHistoryResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getDataContractHistory}
+ */
+function getDataContractHistoryFactory(grpcTransport) {
+  /**
+   * Fetch Data Contract by id
+   *
+   * @typedef {getDataContractHistory}
+   * @param {Buffer} contractId
+   * @param {number} [startAtMs]
+   * @param {number} [limit]
+   * @param {number} [offset]
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetDataContractHistoryResponse>}
+   */
+  async function getDataContractHistory(
+    contractId,
+    startAtMs = 0,
+    limit = 10,
+    offset = 0,
+    options = {},
+  ) {
+    const { GetDataContractHistoryRequestV0 } = GetDataContractHistoryRequest;
+    const getDataContractHistoryRequest = new GetDataContractHistoryRequest();
+
+    // need to convert objects inherited from Buffer to pure buffer as google protobuf
+    // doesn't support extended buffers
+    // https://github.com/protocolbuffers/protobuf/blob/master/js/binary/utils.js#L1049
+    if (Buffer.isBuffer(contractId)) {
+      // eslint-disable-next-line no-param-reassign
+      contractId = Buffer.from(contractId);
+    }
+
+    getDataContractHistoryRequest.setV0(
+      new GetDataContractHistoryRequestV0()
+        .setId(contractId)
+        .setStartAtMs(startAtMs)
+        .setLimit(new UInt32Value([limit]))
+        .setOffset(new UInt32Value([offset]))
+        .setProve(!!options.prove),
+    );
+
+    let lastError;
+
+    // TODO: simple retry before the dapi versioning is properly implemented
+    for (let i = 0; i < 3; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const getDataContractHistoryResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getDataContractHistory',
+          getDataContractHistoryRequest,
+          options,
+        );
+
+        return GetDataContractHistoryResponse.createFromProto(getDataContractHistoryResponse);
+      } catch (e) {
+        if (e instanceof InvalidResponseError) {
+          lastError = e;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // If we made it past the cycle it means that the retry didn't work,
+    // and we're throwing the last error encountered
+    throw lastError;
+  }
+
+  return getDataContractHistory;
+}
+
+module.exports = getDataContractHistoryFactory;

package/lib/methods/platform/getDocuments/GetDocumentsResponse.js

@@ -26,8 +26,11 @@ class GetDocumentsResponse extends AbstractResponse {
   static createFromProto(proto) {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
+    const documents = proto.getV0().getDocuments();
+
     return new GetDocumentsResponse(
-      proto.getDocumentsList().map((document) => Buffer.from(document)),
+      documents !== undefined
+        ? documents.getDocumentsList().map((document) => Buffer.from(document)) : [],
       metadata,
       proof,
     );

package/lib/methods/platform/getDocuments/getDocumentsFactory.js

@@ -43,6 +43,7 @@ function getDocumentsFactory(grpcTransport) {
       orderBySerialized = cbor.encode(orderBy);
     }
 
+    const { GetDocumentsRequestV0 } = GetDocumentsRequest;
     const getDocumentsRequest = new GetDocumentsRequest();
     // need to convert Identifier to pure buffer as google protobuf doesn't support extended buffers
     // https://github.com/protocolbuffers/protobuf/blob/master/js/binary/utils.js#L1049
@@ -55,14 +56,17 @@ function getDocumentsFactory(grpcTransport) {
       contractId = Buffer.from(contractId);
     }
 
-    getDocumentsRequest.setDataContractId(contractId);
-    getDocumentsRequest.setDocumentType(type);
-    getDocumentsRequest.setWhere(whereSerialized);
-    getDocumentsRequest.setOrderBy(orderBySerialized);
-    getDocumentsRequest.setLimit(limit);
-    getDocumentsRequest.setStartAfter(startAfter);
-    getDocumentsRequest.setStartAt(startAt);
-    getDocumentsRequest.setProve(!!options.prove);
+    getDocumentsRequest.setV0(
+      new GetDocumentsRequestV0()
+        .setDataContractId(contractId)
+        .setDocumentType(type)
+        .setWhere(whereSerialized)
+        .setOrderBy(orderBySerialized)
+        .setLimit(limit)
+        .setStartAfter(startAfter)
+        .setStartAt(startAt)
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

package/lib/methods/platform/getEpochsInfo/EpochInfo.js

@@ -0,0 +1,54 @@
+class EpochInfo {
+  /**
+   *
+   * @param {number} number
+   * @param {number} firstBlockHeight
+   * @param {number} firstCoreBlockHeight
+   * @param {number} startTime
+   * @param {number} feeMultiplier
+   */
+  constructor(number, firstBlockHeight, firstCoreBlockHeight, startTime, feeMultiplier) {
+    this.number = number;
+    this.firstBlockHeight = firstBlockHeight;
+    this.firstCoreBlockHeight = firstCoreBlockHeight;
+    this.startTime = startTime;
+    this.feeMultiplier = feeMultiplier;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getNumber() {
+    return this.number;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFirstBlockHeight() {
+    return this.firstBlockHeight;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFirstCoreBlockHeight() {
+    return this.firstCoreBlockHeight;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getStartTime() {
+    return this.startTime;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFeeMultiplier() {
+    return this.feeMultiplier;
+  }
+}
+
+module.exports = EpochInfo;

package/lib/methods/platform/getEpochsInfo/GetEpochsInfoResponse.js

@@ -0,0 +1,59 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const EpochInfo = require('./EpochInfo');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetEpochsInfoResponse extends AbstractResponse {
+  /**
+   * @param {EpochInfo[]} epochsInfo
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(epochsInfo, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.epochsInfo = epochsInfo;
+  }
+
+  /**
+   * @returns {EpochInfo[]}
+   */
+  getEpochsInfo() {
+    return this.epochsInfo;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetEpochsInfoResponse}
+   */
+  static createFromProto(proto) {
+    const epochs = proto.getV0().getEpochs();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if (!epochs && !proof) {
+      throw new InvalidResponseError('Epochs are not defined');
+    }
+
+    let epochsInfo = [];
+
+    const epochsInfoList = epochs && epochs.getEpochInfosList();
+    if (epochsInfoList) {
+      epochsInfo = epochsInfoList.map((epoch) => new EpochInfo(
+        epoch.getNumber(),
+        epoch.getFirstBlockHeight(),
+        epoch.getFirstCoreBlockHeight(),
+        epoch.getStartTime(),
+        epoch.getFeeMultiplier(),
+      ));
+    }
+
+    return new GetEpochsInfoResponse(
+      epochsInfo,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetEpochsInfoResponse;

package/lib/methods/platform/getEpochsInfo/getEpochsInfoFactory.js

@@ -0,0 +1,69 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetEpochsInfoRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const { UInt32Value } = require('google-protobuf/google/protobuf/wrappers_pb');
+
+const GetEpochsInfoResponse = require('./GetEpochsInfoResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getEpochsInfo}
+ */
+function getEpochsInfoFactory(grpcTransport) {
+  /**
+   * Fetch the epoch info
+   *
+   * @typedef {getEpochsInfo}
+   * @param {number} startEpoch
+   * @param {number} count
+   * @param {DAPIClientOptions & {prove: boolean, ascending: boolean}} [options]
+   * @returns {Promise<GetEpochsInfoResponse>}
+   */
+  async function getEpochsInfo(startEpoch, count, options = {}) {
+    const { GetEpochsInfoRequestV0 } = GetEpochsInfoRequest;
+    const getEpochInfosRequest = new GetEpochsInfoRequest();
+    getEpochInfosRequest.setV0(
+      new GetEpochsInfoRequestV0()
+        .setStartEpoch(new UInt32Value([startEpoch]))
+        .setCount(count)
+        .setAscending(!!options.ascending)
+        .setProve(!!options.prove),
+    );
+
+    let lastError;
+
+    // TODO: simple retry before the dapi versioning is properly implemented
+    for (let i = 0; i < 3; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const getEpochsInfoResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getEpochsInfo',
+          getEpochInfosRequest,
+          options,
+        );
+
+        return GetEpochsInfoResponse.createFromProto(getEpochsInfoResponse);
+      } catch (e) {
+        if (e instanceof InvalidResponseError) {
+          lastError = e;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // If we made it past the cycle it means that the retry didn't work,
+    // and we're throwing the last error encountered
+    throw lastError;
+  }
+
+  return getEpochsInfo;
+}
+
+module.exports = getEpochsInfoFactory;

package/lib/methods/platform/getIdentitiesByPublicKeyHashes/GetIdentitiesByPublicKeyHashesResponse.js

@@ -26,8 +26,17 @@ class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
   static createFromProto(proto) {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
+    const identitiesList = proto.getV0().getIdentities();
+
     return new GetIdentitiesByPublicKeyHashesResponse(
-      proto.getIdentitiesList_asU8().map((identity) => Buffer.from(identity)),
+      identitiesList !== undefined
+        ? identitiesList.getIdentityEntriesList()
+          .map((identity) => {
+            const value = identity.getValue();
+            // TODO: rework to return whole `identity.getValue()` instead of inner getValue()
+            return value && Buffer.from(value.getValue());
+          })
+        : [],
       metadata,
       proof,
     );