@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/rpc-util.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var core_crypto = require('./core/crypto.js');
+var core_logger = require('./core/logger.js');
+require('crypto');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+function createMethodResolver({service, methodFn, methodName}) {
+  const methodPath = `${service.name}.${methodName}`;
+
+  return {
+    name: methodPath,
+    resolver: async (params = {}) => {
+      try {
+        let result;
+
+        if (!methodFn) {
+          throw new Error('Resolver is undefined');
+        }
+
+        if (params.__args) {
+          result = methodFn.apply(service, params.__args);
+        } else {
+          result = methodFn.apply(service, [params]);
+        }
+
+        return Promise.resolve(result).then(value => {
+          core_logger.Logger.debug(`Result for ${methodPath}`, value);
+          return value;
+        });
+      } catch (err) {
+        core_logger.Logger.debug(`Error for ${methodPath}`, err.toString());
+        throw err;
+      }
+    },
+  };
+}
+
+function createRpcService(service) {
+  const {name, rpcMethods} = service;
+
+  assert__default["default"](
+    typeof name === 'string',
+    `invalid name: ${name} for service ${service.constructor.name}`,
+  );
+  assert__default["default"](
+    typeof rpcMethods === 'object',
+    `invalid routes: ${rpcMethods} for service ${service.constructor.name}`,
+  );
+
+  let methods = rpcMethods;
+
+  if (!Array.isArray(rpcMethods)) {
+    return Object.keys(rpcMethods).map(key => {
+      return createMethodResolver({
+        methodFn: rpcMethods[key],
+        methodName: key,
+        service,
+      });
+    });
+  }
+
+  return methods.map(methodFn => {
+    return createMethodResolver({
+      methodFn,
+      methodName: methodFn.name,
+      service,
+    });
+  });
+}
+
+function patchRpcServer(server) {
+  server.__receive = server.receive;
+
+  server.receive = function (reqData) {
+    try {
+      if (core_crypto.SECURE_JSON_RPC && reqData.params && reqData.params.encryptedData) {
+        const params = core_crypto.decryptData(reqData.params);
+        reqData.params = JSON.parse(params).reqParams;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+
+    return server.__receive(reqData);
+  };
+
+  return server;
+}
+
+exports.createMethodResolver = createMethodResolver;
+exports.createRpcService = createRpcService;
+exports.patchRpcServer = patchRpcServer;

package/lib/rpc-util.mjs

@@ -0,0 +1,89 @@
+import assert from 'assert';
+import { SECURE_JSON_RPC, decryptData } from './core/crypto.mjs';
+import { Logger } from './core/logger.mjs';
+import 'crypto';
+
+function createMethodResolver({service, methodFn, methodName}) {
+  const methodPath = `${service.name}.${methodName}`;
+
+  return {
+    name: methodPath,
+    resolver: async (params = {}) => {
+      try {
+        let result;
+
+        if (!methodFn) {
+          throw new Error('Resolver is undefined');
+        }
+
+        if (params.__args) {
+          result = methodFn.apply(service, params.__args);
+        } else {
+          result = methodFn.apply(service, [params]);
+        }
+
+        return Promise.resolve(result).then(value => {
+          Logger.debug(`Result for ${methodPath}`, value);
+          return value;
+        });
+      } catch (err) {
+        Logger.debug(`Error for ${methodPath}`, err.toString());
+        throw err;
+      }
+    },
+  };
+}
+
+function createRpcService(service) {
+  const {name, rpcMethods} = service;
+
+  assert(
+    typeof name === 'string',
+    `invalid name: ${name} for service ${service.constructor.name}`,
+  );
+  assert(
+    typeof rpcMethods === 'object',
+    `invalid routes: ${rpcMethods} for service ${service.constructor.name}`,
+  );
+
+  let methods = rpcMethods;
+
+  if (!Array.isArray(rpcMethods)) {
+    return Object.keys(rpcMethods).map(key => {
+      return createMethodResolver({
+        methodFn: rpcMethods[key],
+        methodName: key,
+        service,
+      });
+    });
+  }
+
+  return methods.map(methodFn => {
+    return createMethodResolver({
+      methodFn,
+      methodName: methodFn.name,
+      service,
+    });
+  });
+}
+
+function patchRpcServer(server) {
+  server.__receive = server.receive;
+
+  server.receive = function (reqData) {
+    try {
+      if (SECURE_JSON_RPC && reqData.params && reqData.params.encryptedData) {
+        const params = decryptData(reqData.params);
+        reqData.params = JSON.parse(params).reqParams;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+
+    return server.__receive(reqData);
+  };
+
+  return server;
+}
+
+export { createMethodResolver, createRpcService, patchRpcServer };

package/lib/sandbox-rpc-server.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var jsonRpc2_0 = require('json-rpc-2.0');
+var rpcUtil = require('./rpc-util.js');
+var services_sandbox = require('./services/sandbox.js');
+require('assert');
+require('./core/crypto.js');
+require('crypto');
+require('./core/logger.js');
+require('./services/pex/service.js');
+require('./services/pex/config.js');
+require('@sphereon/pex');
+
+const rpcServer = new jsonRpc2_0.JSONRPCServer();
+
+services_sandbox.forEach(service => {
+  const rpcService = rpcUtil.createRpcService(service);
+
+  rpcService.forEach(method => {
+    rpcServer.addMethod(method.name, params => {
+      return Promise.resolve(method.resolver(params));
+    });
+  });
+});
+
+var rpcServer$1 = rpcUtil.patchRpcServer(rpcServer);
+
+module.exports = rpcServer$1;

package/lib/sandbox-rpc-server.mjs

@@ -0,0 +1,26 @@
+import { JSONRPCServer } from 'json-rpc-2.0';
+import { createRpcService, patchRpcServer } from './rpc-util.mjs';
+import services from './services/sandbox.mjs';
+import 'assert';
+import './core/crypto.mjs';
+import 'crypto';
+import './core/logger.mjs';
+import './services/pex/service.mjs';
+import './services/pex/config.mjs';
+import '@sphereon/pex';
+
+const rpcServer = new JSONRPCServer();
+
+services.forEach(service => {
+  const rpcService = createRpcService(service);
+
+  rpcService.forEach(method => {
+    rpcServer.addMethod(method.name, params => {
+      return Promise.resolve(method.resolver(params));
+    });
+  });
+});
+
+var rpcServer$1 = patchRpcServer(rpcServer);
+
+export { rpcServer$1 as default };

package/lib/sandbox.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var rpcClient = require('./rpc-client.js');
+var logger = require('./logger.js');
+var sandboxRpcServer = require('./sandbox-rpc-server.js');
+require('assert');
+require('json-rpc-2.0');
+require('./core/crypto.js');
+require('crypto');
+require('./core/logger.js');
+require('./rpc-util.js');
+require('./services/sandbox.js');
+require('./services/pex/service.js');
+require('./services/pex/config.js');
+require('@sphereon/pex');
+
+global.fetch = () => {
+  throw new Error('fetch is not available in the sandbox');
+};
+
+global.XMLHttpRequest = () => {
+  throw new Error('XMLHttpRequest is not available in the sandbox');
+};
+
+global.WebSocket = () => {
+  throw new Error('WebSocket is not available in the sandbox');
+};
+
+global.Worker = () => {
+  throw new Error('Worker is not available in the sandbox');
+};
+
+global.ServiceWorker = () => {
+  throw new Error('ServiceWorker is not available in the sandbox');
+};
+
+global.XMLHttpRequestEventTarget = () => {
+  throw new Error('XMLHttpRequestEventTarget is not available in the sandbox');
+};
+
+global.SharedWorker = () => {
+  throw new Error('SharedWorker is not available in the sandbox');
+};
+
+global.WebSocketEventTarget = () => {
+  throw new Error('WebSocketEventTarget is not available in the sandbox');
+};
+
+rpcClient.initRpcClient(jsonRPCRequest => {
+  postMessage({
+    type: 'json-rpc-request',
+    body: jsonRPCRequest,
+  });
+
+  return Promise.resolve(jsonRPCRequest);
+});
+
+const postMessage = message => {
+  if (window.ReactNativeWebView) {
+    window.ReactNativeWebView.postMessage(JSON.stringify(message));
+  } else {
+    console.log(message);
+  }
+};
+
+const addEventListener = (...args) =>
+  (navigator.appVersion.includes('Android')
+    ? document
+    : window
+  ).addEventListener(...args);
+
+logger.setLogger({
+  log: (...params) => {
+    // Logger disabled for sandbox
+  },
+  debug: (...params) => {
+    // Logger disabled for sandbox
+  },
+});
+
+global.handleEvent = event => {
+  const data = event.data;
+
+  if (data && data.type === 'json-rpc-request') {
+    sandboxRpcServer.receive(data.body).then(response => {
+      postMessage({
+        type: 'json-rpc-response',
+        body: response,
+      });
+    });
+  }
+
+  if (data && data.type === 'json-rpc-response') {
+    rpcClient.getRpcClient().receive(data.body);
+  }
+};
+
+addEventListener('message', global.handleEvent);
+
+postMessage({
+  type: 'json-rpc-ready',
+});

package/lib/sandbox.mjs

@@ -0,0 +1,100 @@
+import { initRpcClient, getRpcClient } from './rpc-client.mjs';
+import { setLogger } from './logger.mjs';
+import rpcServer from './sandbox-rpc-server.mjs';
+import 'assert';
+import 'json-rpc-2.0';
+import './core/crypto.mjs';
+import 'crypto';
+import './core/logger.mjs';
+import './rpc-util.mjs';
+import './services/sandbox.mjs';
+import './services/pex/service.mjs';
+import './services/pex/config.mjs';
+import '@sphereon/pex';
+
+global.fetch = () => {
+  throw new Error('fetch is not available in the sandbox');
+};
+
+global.XMLHttpRequest = () => {
+  throw new Error('XMLHttpRequest is not available in the sandbox');
+};
+
+global.WebSocket = () => {
+  throw new Error('WebSocket is not available in the sandbox');
+};
+
+global.Worker = () => {
+  throw new Error('Worker is not available in the sandbox');
+};
+
+global.ServiceWorker = () => {
+  throw new Error('ServiceWorker is not available in the sandbox');
+};
+
+global.XMLHttpRequestEventTarget = () => {
+  throw new Error('XMLHttpRequestEventTarget is not available in the sandbox');
+};
+
+global.SharedWorker = () => {
+  throw new Error('SharedWorker is not available in the sandbox');
+};
+
+global.WebSocketEventTarget = () => {
+  throw new Error('WebSocketEventTarget is not available in the sandbox');
+};
+
+initRpcClient(jsonRPCRequest => {
+  postMessage({
+    type: 'json-rpc-request',
+    body: jsonRPCRequest,
+  });
+
+  return Promise.resolve(jsonRPCRequest);
+});
+
+const postMessage = message => {
+  if (window.ReactNativeWebView) {
+    window.ReactNativeWebView.postMessage(JSON.stringify(message));
+  } else {
+    console.log(message);
+  }
+};
+
+const addEventListener = (...args) =>
+  (navigator.appVersion.includes('Android')
+    ? document
+    : window
+  ).addEventListener(...args);
+
+setLogger({
+  log: (...params) => {
+    // Logger disabled for sandbox
+  },
+  debug: (...params) => {
+    // Logger disabled for sandbox
+  },
+});
+
+global.handleEvent = event => {
+  const data = event.data;
+
+  if (data && data.type === 'json-rpc-request') {
+    rpcServer.receive(data.body).then(response => {
+      postMessage({
+        type: 'json-rpc-response',
+        body: response,
+      });
+    });
+  }
+
+  if (data && data.type === 'json-rpc-response') {
+    getRpcClient().receive(data.body);
+  }
+};
+
+addEventListener('message', global.handleEvent);
+
+postMessage({
+  type: 'json-rpc-ready',
+});

package/lib/services/credential/bbs-revocation.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cryptoWasmTs = require('@docknetwork/crypto-wasm-ts');
+var dock = require('@docknetwork/sdk');
+var util = require('@polkadot/util');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dock__default = /*#__PURE__*/_interopDefaultLegacy(dock);
+
+const getWitnessDetails = async (credential, _membershipWitness) => {
+    const { credentialStatus } = credential;
+    const registryId = credentialStatus?.id.replace('dock:accumulator:', '');
+    const revocationIndex = credentialStatus.revocationId;
+    const queriedAccumulator = await dock__default["default"].accumulatorModule.getAccumulator(registryId, false);
+    if (!queriedAccumulator) {
+        throw new Error('Accumulator not found');
+    }
+    const accumulator = cryptoWasmTs.PositiveAccumulator.fromAccumulated(util.hexToU8a(queriedAccumulator.accumulated));
+    const encodedRevId = cryptoWasmTs.Encoder.defaultEncodeFunc()(revocationIndex.toString());
+    const publicKey = await dock__default["default"].accumulatorModule.getPublicKeyByHexDid(queriedAccumulator.keyRef[0], queriedAccumulator.keyRef[1]);
+    const params = cryptoWasmTs.dockAccumulatorParams();
+    const pk = new cryptoWasmTs.AccumulatorPublicKey(util.hexToU8a(publicKey.bytes));
+    const membershipWitness = new cryptoWasmTs.VBMembershipWitness(util.hexToU8a(_membershipWitness));
+    return {
+        encodedRevId,
+        membershipWitness,
+        pk,
+        params,
+        accumulator,
+    };
+};
+const getIsRevoked = async (credential, _membershipWitness) => {
+    const { encodedRevId, membershipWitness, pk, params, accumulator } = await getWitnessDetails(credential, _membershipWitness);
+    try {
+        return !accumulator.verifyMembershipWitness(encodedRevId, membershipWitness, pk, params);
+    }
+    catch (err) {
+        console.error(err);
+        return false;
+    }
+};
+
+exports.getIsRevoked = getIsRevoked;
+exports.getWitnessDetails = getWitnessDetails;

package/lib/services/credential/bbs-revocation.mjs

@@ -0,0 +1,38 @@
+import { PositiveAccumulator, Encoder, dockAccumulatorParams, AccumulatorPublicKey, VBMembershipWitness } from '@docknetwork/crypto-wasm-ts';
+import dock from '@docknetwork/sdk';
+import { hexToU8a } from '@polkadot/util';
+
+const getWitnessDetails = async (credential, _membershipWitness) => {
+    const { credentialStatus } = credential;
+    const registryId = credentialStatus?.id.replace('dock:accumulator:', '');
+    const revocationIndex = credentialStatus.revocationId;
+    const queriedAccumulator = await dock.accumulatorModule.getAccumulator(registryId, false);
+    if (!queriedAccumulator) {
+        throw new Error('Accumulator not found');
+    }
+    const accumulator = PositiveAccumulator.fromAccumulated(hexToU8a(queriedAccumulator.accumulated));
+    const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
+    const publicKey = await dock.accumulatorModule.getPublicKeyByHexDid(queriedAccumulator.keyRef[0], queriedAccumulator.keyRef[1]);
+    const params = dockAccumulatorParams();
+    const pk = new AccumulatorPublicKey(hexToU8a(publicKey.bytes));
+    const membershipWitness = new VBMembershipWitness(hexToU8a(_membershipWitness));
+    return {
+        encodedRevId,
+        membershipWitness,
+        pk,
+        params,
+        accumulator,
+    };
+};
+const getIsRevoked = async (credential, _membershipWitness) => {
+    const { encodedRevId, membershipWitness, pk, params, accumulator } = await getWitnessDetails(credential, _membershipWitness);
+    try {
+        return !accumulator.verifyMembershipWitness(encodedRevId, membershipWitness, pk, params);
+    }
+    catch (err) {
+        console.error(err);
+        return false;
+    }
+};
+
+export { getIsRevoked, getWitnessDetails };

package/lib/services/credential/bound-check.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var legosnark = require('@docknetwork/crypto-wasm-ts/lib/legosnark');
+var utilCrypto = require('@polkadot/util-crypto');
+var base64url = require('base64url');
+var services_credential_pexHelpers = require('./pex-helpers.js');
+require('@astronautlabs/jsonpath');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var base64url__default = /*#__PURE__*/_interopDefaultLegacy(base64url);
+
+/**
+ * Receive a presentation builder and a proof request template
+ * Convert the proof request template into enforce bound calls on the presentation builder
+ * @param param0
+ */
+function applyEnforceBounds({ builder, proofRequest, provingKeyId, provingKey, selectedCredentials, }) {
+    const descriptorBounds = services_credential_pexHelpers.pexToBounds(proofRequest.request, selectedCredentials);
+    let skipProvingKey = false;
+    descriptorBounds.forEach((items, credentialIdx) => {
+        items.forEach((bound) => {
+            builder.enforceBounds(credentialIdx, bound.attributeName, bound.min, bound.max, provingKeyId, skipProvingKey ? undefined : provingKey);
+            skipProvingKey = true;
+        });
+    });
+    return descriptorBounds;
+}
+async function fetchBlobFromUrl(url) {
+    try {
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        return new Uint8Array(arrayBuffer);
+    }
+    catch (err) {
+        throw new Error(`Error fetching proving key: ${err.message}`);
+    }
+}
+function blobFromBase64(base64String) {
+    const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
+    return base64url__default["default"].toBuffer(cleanedBase64);
+}
+function isBase64OrDataUrl(str) {
+    return (utilCrypto.isBase64(str) ||
+        str.indexOf('data:application/octet-stream') > -1);
+}
+async function fetchProvingKey(proofRequest) {
+    let blob;
+    if (isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
+        console.log('Is base64');
+        blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
+    }
+    else {
+        console.log('is not base64');
+        blob = await fetchBlobFromUrl(proofRequest.boundCheckSnarkKey);
+    }
+    const provingKey = new legosnark.LegoProvingKey(blob);
+    return { provingKey, provingKeyId: 'key0' };
+}
+const MAX_DATE_PLACEHOLDER = 884541351600000;
+const MIN_DATE_PLACEHOLDER = -17592186044415;
+const MAX_NUMBER = Math.pow(100, 9);
+const MIN_INTEGER = -4294967295;
+const hasProvingKey = (proofRequest) => !!proofRequest.boundCheckSnarkKey;
+
+exports.MAX_DATE_PLACEHOLDER = MAX_DATE_PLACEHOLDER;
+exports.MAX_NUMBER = MAX_NUMBER;
+exports.MIN_DATE_PLACEHOLDER = MIN_DATE_PLACEHOLDER;
+exports.MIN_INTEGER = MIN_INTEGER;
+exports.applyEnforceBounds = applyEnforceBounds;
+exports.blobFromBase64 = blobFromBase64;
+exports.fetchBlobFromUrl = fetchBlobFromUrl;
+exports.fetchProvingKey = fetchProvingKey;
+exports.hasProvingKey = hasProvingKey;
+exports.isBase64OrDataUrl = isBase64OrDataUrl;

package/lib/services/credential/bound-check.mjs

@@ -0,0 +1,60 @@
+import { LegoProvingKey } from '@docknetwork/crypto-wasm-ts/lib/legosnark';
+import { isBase64 } from '@polkadot/util-crypto';
+import base64url from 'base64url';
+import { pexToBounds } from './pex-helpers.mjs';
+import '@astronautlabs/jsonpath';
+
+/**
+ * Receive a presentation builder and a proof request template
+ * Convert the proof request template into enforce bound calls on the presentation builder
+ * @param param0
+ */
+function applyEnforceBounds({ builder, proofRequest, provingKeyId, provingKey, selectedCredentials, }) {
+    const descriptorBounds = pexToBounds(proofRequest.request, selectedCredentials);
+    let skipProvingKey = false;
+    descriptorBounds.forEach((items, credentialIdx) => {
+        items.forEach((bound) => {
+            builder.enforceBounds(credentialIdx, bound.attributeName, bound.min, bound.max, provingKeyId, skipProvingKey ? undefined : provingKey);
+            skipProvingKey = true;
+        });
+    });
+    return descriptorBounds;
+}
+async function fetchBlobFromUrl(url) {
+    try {
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        return new Uint8Array(arrayBuffer);
+    }
+    catch (err) {
+        throw new Error(`Error fetching proving key: ${err.message}`);
+    }
+}
+function blobFromBase64(base64String) {
+    const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
+    return base64url.toBuffer(cleanedBase64);
+}
+function isBase64OrDataUrl(str) {
+    return (isBase64(str) ||
+        str.indexOf('data:application/octet-stream') > -1);
+}
+async function fetchProvingKey(proofRequest) {
+    let blob;
+    if (isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
+        console.log('Is base64');
+        blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
+    }
+    else {
+        console.log('is not base64');
+        blob = await fetchBlobFromUrl(proofRequest.boundCheckSnarkKey);
+    }
+    const provingKey = new LegoProvingKey(blob);
+    return { provingKey, provingKeyId: 'key0' };
+}
+const MAX_DATE_PLACEHOLDER = 884541351600000;
+const MIN_DATE_PLACEHOLDER = -17592186044415;
+const MAX_NUMBER = Math.pow(100, 9);
+const MIN_INTEGER = -4294967295;
+const hasProvingKey = (proofRequest) => !!proofRequest.boundCheckSnarkKey;
+
+export { MAX_DATE_PLACEHOLDER, MAX_NUMBER, MIN_DATE_PLACEHOLDER, MIN_INTEGER, applyEnforceBounds, blobFromBase64, fetchBlobFromUrl, fetchProvingKey, hasProvingKey, isBase64OrDataUrl };