@docknetwork/wallet-sdk-wasm 1.7.7-alpha.0 → 1.9.0

package/lib/rpc-util.js

@@ -1,113 +0,0 @@
-'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}) {
-  if (methodFn === undefined) {
-    throw new Error(
-      `Resolver is undefined for ${methodName} in ${service.name}`,
-    );
-  }
-
-  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 => {
-    if (methodFn === undefined) {
-      throw new Error(
-        `Method is undefined in ${
-          service.name
-        }, available methods: ${Object.keys(service.rpcMethods).join(', ')}`,
-      );
-    }
-
-    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

@@ -1,103 +0,0 @@
-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}) {
-  if (methodFn === undefined) {
-    throw new Error(
-      `Resolver is undefined for ${methodName} in ${service.name}`,
-    );
-  }
-
-  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 => {
-    if (methodFn === undefined) {
-      throw new Error(
-        `Method is undefined in ${
-          service.name
-        }, available methods: ${Object.keys(service.rpcMethods).join(', ')}`,
-      );
-    }
-
-    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

@@ -1,28 +0,0 @@
-'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

@@ -1,26 +0,0 @@
-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

@@ -1,102 +0,0 @@
-'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

@@ -1,100 +0,0 @@
-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/blockchain/cached-did-resolver.js

@@ -1,113 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var services_storage_index = require('../storage/index.js');
-require('../storage/service.js');
-require('../storage/service-rpc.js');
-require('../rpc-service-client.js');
-require('assert');
-require('../../rpc-client.js');
-require('json-rpc-2.0');
-require('../../core/crypto.js');
-require('crypto');
-require('../../core/logger.js');
-require('../../logger.js');
-require('../../rpc-util.js');
-
-class CachedDIDResolver {
-    router;
-    ttl;
-    CACHE_PREFIX = 'did-cache:';
-    constructor(router, cacheOptions = {}) {
-        this.router = router;
-        // 1 hour default
-        this.ttl = cacheOptions.ttl || 60 * 60 * 1000;
-    }
-    getCacheKey(did) {
-        return `${this.CACHE_PREFIX}${did}`;
-    }
-    async getCacheEntry(did) {
-        const key = this.getCacheKey(did);
-        const data = await services_storage_index.storageService.getItem(key);
-        try {
-            return data ? JSON.parse(data) : null;
-        }
-        catch (error) {
-            console.error('Error parsing cache entry:', error);
-            return null;
-        }
-    }
-    async setCacheEntry(did, entry) {
-        const key = this.getCacheKey(did);
-        await services_storage_index.storageService.setItem(key, JSON.stringify(entry));
-    }
-    async getCachedDIDs() {
-        const allKeys = await services_storage_index.storageService.getAllKeys();
-        const cachedDIDs = [];
-        allKeys.forEach(key => {
-            if (key.startsWith(this.CACHE_PREFIX)) {
-                cachedDIDs.push(key.replace(this.CACHE_PREFIX, ''));
-            }
-        });
-        return cachedDIDs;
-    }
-    async resolve(did) {
-        const cached = await this.getCacheEntry(did);
-        if (cached) {
-            if (Date.now() - cached.timestamp < this.ttl) {
-                console.log('Cache hit for:', did);
-                return cached.value;
-            }
-            else {
-                console.log('Cache expired for:', did, 'returning stale value and refreshing in background');
-                this.refreshInBackground(did);
-                return cached.value;
-            }
-        }
-        console.log('Cache miss, resolving:', did);
-        const result = await this.router.resolve(did);
-        await this.setCacheEntry(result.id, {
-            value: result,
-            id: result.id,
-            timestamp: Date.now()
-        });
-        return result;
-    }
-    async refreshInBackground(did) {
-        try {
-            console.log('Refreshing cache in background for:', did);
-            const result = await this.router.resolve(did);
-            await this.setCacheEntry(did, {
-                value: result,
-                id: did,
-                timestamp: Date.now()
-            });
-            console.log('Background refresh completed for:', did);
-        }
-        catch (error) {
-            console.warn('Background refresh failed for:', did, error);
-        }
-    }
-    /**
-     * if the did is provided, it will remove the specific did from the cache
-     * otherwise, it will clear the entire cache
-     * @param did
-     */
-    async clearCache(did) {
-        if (did) {
-            const key = this.getCacheKey(did);
-            await services_storage_index.storageService.removeItem(key);
-        }
-        else {
-            const allKeys = await services_storage_index.storageService.getAllKeys();
-            const cacheKeys = allKeys.filter(key => key.startsWith(this.CACHE_PREFIX));
-            await Promise.all(cacheKeys.map(key => services_storage_index.storageService.removeItem(key)));
-        }
-    }
-    supports(id) {
-        return this.router.supports(id);
-    }
-}
-
-exports.CachedDIDResolver = CachedDIDResolver;

package/lib/services/blockchain/cached-did-resolver.mjs

@@ -1,109 +0,0 @@
-import { storageService } from '../storage/index.mjs';
-import '../storage/service.mjs';
-import '../storage/service-rpc.mjs';
-import '../rpc-service-client.mjs';
-import 'assert';
-import '../../rpc-client.mjs';
-import 'json-rpc-2.0';
-import '../../core/crypto.mjs';
-import 'crypto';
-import '../../core/logger.mjs';
-import '../../logger.mjs';
-import '../../rpc-util.mjs';
-
-class CachedDIDResolver {
-    router;
-    ttl;
-    CACHE_PREFIX = 'did-cache:';
-    constructor(router, cacheOptions = {}) {
-        this.router = router;
-        // 1 hour default
-        this.ttl = cacheOptions.ttl || 60 * 60 * 1000;
-    }
-    getCacheKey(did) {
-        return `${this.CACHE_PREFIX}${did}`;
-    }
-    async getCacheEntry(did) {
-        const key = this.getCacheKey(did);
-        const data = await storageService.getItem(key);
-        try {
-            return data ? JSON.parse(data) : null;
-        }
-        catch (error) {
-            console.error('Error parsing cache entry:', error);
-            return null;
-        }
-    }
-    async setCacheEntry(did, entry) {
-        const key = this.getCacheKey(did);
-        await storageService.setItem(key, JSON.stringify(entry));
-    }
-    async getCachedDIDs() {
-        const allKeys = await storageService.getAllKeys();
-        const cachedDIDs = [];
-        allKeys.forEach(key => {
-            if (key.startsWith(this.CACHE_PREFIX)) {
-                cachedDIDs.push(key.replace(this.CACHE_PREFIX, ''));
-            }
-        });
-        return cachedDIDs;
-    }
-    async resolve(did) {
-        const cached = await this.getCacheEntry(did);
-        if (cached) {
-            if (Date.now() - cached.timestamp < this.ttl) {
-                console.log('Cache hit for:', did);
-                return cached.value;
-            }
-            else {
-                console.log('Cache expired for:', did, 'returning stale value and refreshing in background');
-                this.refreshInBackground(did);
-                return cached.value;
-            }
-        }
-        console.log('Cache miss, resolving:', did);
-        const result = await this.router.resolve(did);
-        await this.setCacheEntry(result.id, {
-            value: result,
-            id: result.id,
-            timestamp: Date.now()
-        });
-        return result;
-    }
-    async refreshInBackground(did) {
-        try {
-            console.log('Refreshing cache in background for:', did);
-            const result = await this.router.resolve(did);
-            await this.setCacheEntry(did, {
-                value: result,
-                id: did,
-                timestamp: Date.now()
-            });
-            console.log('Background refresh completed for:', did);
-        }
-        catch (error) {
-            console.warn('Background refresh failed for:', did, error);
-        }
-    }
-    /**
-     * if the did is provided, it will remove the specific did from the cache
-     * otherwise, it will clear the entire cache
-     * @param did
-     */
-    async clearCache(did) {
-        if (did) {
-            const key = this.getCacheKey(did);
-            await storageService.removeItem(key);
-        }
-        else {
-            const allKeys = await storageService.getAllKeys();
-            const cacheKeys = allKeys.filter(key => key.startsWith(this.CACHE_PREFIX));
-            await Promise.all(cacheKeys.map(key => storageService.removeItem(key)));
-        }
-    }
-    supports(id) {
-        return this.router.supports(id);
-    }
-}
-
-export { CachedDIDResolver };

package/lib/services/blockchain/configs.js

@@ -1,7 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const validation = {};
-
-exports.validation = validation;