@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/dock/service.mjs

@@ -0,0 +1,126 @@
+import dock from '@docknetwork/sdk';
+import { WildcardMultiResolver, DockResolver, DIDKeyResolver, UniversalResolver } from '@docknetwork/sdk/resolver';
+import { initializeWasm } from '@docknetwork/crypto-wasm-ts/lib/index';
+import { EventEmitter } from 'events';
+import { Logger } from '../../core/logger.mjs';
+import { once } from '../../modules/event-manager.mjs';
+import { validation } from './configs.mjs';
+import 'assert';
+
+// @ts-nocheck
+let dockInstance = dock;
+function getDock() {
+    return dockInstance;
+}
+function setDock(instance) {
+    dockInstance = instance;
+}
+// Create a resolver in order to lookup DIDs for verifying
+const universalResolverUrl = 'https://uniresolver.io';
+// class WalletSDKResolver extends WildcardMultiResolver {
+//   async resolve(did) {
+//     const trimmedDID = did.split('#')[0];
+//     const document = await super.resolve(trimmedDID);
+//     return document;
+//   }
+// }
+/**
+ *
+ */
+class DockService {
+    dock;
+    isDockReady = false;
+    resolver;
+    static Events = {
+        DOCK_READY: 'dock-ready',
+    };
+    rpcMethods = [
+        DockService.prototype.disconnect,
+        DockService.prototype.ensureDockReady,
+        DockService.prototype.init,
+        DockService.prototype.isApiConnected,
+        DockService.prototype.getAddress,
+    ];
+    constructor() {
+        this.name = 'dock';
+        this.dock = dock;
+        this.emitter = new EventEmitter();
+        this.resolver = this.createDIDResolver();
+    }
+    /**
+     *
+     * @returns
+     */
+    async ensureDockReady() {
+        if (this.isDockReady) {
+            return;
+        }
+        return once(this.emitter, DockService.Events.DOCK_READY);
+    }
+    createDIDResolver() {
+        return new WildcardMultiResolver([
+            new DockResolver(getDock()),
+            new DIDKeyResolver(),
+            new UniversalResolver(universalResolverUrl),
+        ]);
+    }
+    /**
+     *
+     * @param {*} params
+     * @returns
+     */
+    async init(params) {
+        validation.init(params);
+        if (this.dock.isConnected) {
+            await this.dock.disconnect();
+        }
+        Logger.info(`Attempt to initialized substrate at: ${params.address}`);
+        await getDock().init(params);
+        this.address = params.address;
+        this.resolver = this.createDIDResolver();
+        if (process.env.NODE_ENV !== 'test' || process.env.API_MOCK_DISABLED === 'true') {
+            await initializeWasm();
+        }
+        Logger.info(`Substrate initialized at: ${params.address}`);
+        this._setDockReady(true);
+        return true;
+    }
+    /**
+     *
+     * @returns
+     */
+    async disconnect() {
+        const result = await this.dock.disconnect();
+        this._setDockReady(false);
+        return result;
+    }
+    async waitDockReady() {
+        return new Promise(resolve => {
+            if (this.isDockReady) {
+                resolve();
+            }
+            else {
+                this.emitter.once(DockService.Events.DOCK_READY, resolve);
+            }
+        });
+    }
+    /**
+     *
+     * @returns
+     */
+    async isApiConnected() {
+        return this.isDockReady;
+    }
+    async getAddress() {
+        return this.dock.address;
+    }
+    _setDockReady(isDockReady) {
+        this.isDockReady = isDockReady;
+        if (isDockReady) {
+            this.emitter.emit(DockService.Events.DOCK_READY);
+        }
+    }
+}
+const dockService = new DockService();
+
+export { DockService, dockService, getDock, setDock, universalResolverUrl };

package/lib/services/example/configs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var core_validation = require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+const validation = {
+  sum(params           ) {
+    assert__default["default"](core_validation.isNumberValid(params.number1), 'invalid number1');
+    assert__default["default"](core_validation.isNumberValid(params.number2), 'invalid number2');
+  },
+};
+
+exports.validation = validation;

package/lib/services/example/configs.mjs

@@ -0,0 +1,13 @@
+import assert from 'assert';
+import { isNumberValid } from '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+const validation = {
+  sum(params           ) {
+    assert(isNumberValid(params.number1), 'invalid number1');
+    assert(isNumberValid(params.number2), 'invalid number2');
+  },
+};
+
+export { validation };

package/lib/services/example/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_example_serviceRpc = require('./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');
+
+const exampleService = new services_example_serviceRpc.ExampleServiceRpc();
+
+exports.exampleService = exampleService;

package/lib/services/example/index.mjs

@@ -0,0 +1,14 @@
+import { ExampleServiceRpc } from './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';
+
+const exampleService = new ExampleServiceRpc();
+
+export { exampleService };

package/lib/services/example/service-rpc.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = 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 ExampleServiceRpc extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super('example');
+  }
+
+  sum()               {
+    return this.call('sum');
+  }
+}
+
+exports.ExampleServiceRpc = ExampleServiceRpc;

package/lib/services/example/service-rpc.mjs

@@ -0,0 +1,21 @@
+import { RpcService } from '../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 ExampleServiceRpc extends RpcService {
+  constructor() {
+    super('example');
+  }
+
+  sum()               {
+    return this.call('sum');
+  }
+}
+
+export { ExampleServiceRpc };

package/lib/services/example/service.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_example_configs = require('./configs.js');
+require('assert');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+// @ts-nocheck
+class ExampleService {
+    rpcMethods = [ExampleService.prototype.sum];
+    constructor() { }
+    sum(params) {
+        services_example_configs.validation.sum(params);
+        return params.number1 + params.number2;
+    }
+}
+const exampleService = new ExampleService();
+
+exports.ExampleService = ExampleService;
+exports.exampleService = exampleService;

package/lib/services/example/service.mjs

@@ -0,0 +1,18 @@
+import { validation } from './configs.mjs';
+import 'assert';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+// @ts-nocheck
+class ExampleService {
+    rpcMethods = [ExampleService.prototype.sum];
+    constructor() { }
+    sum(params) {
+        validation.sum(params);
+        return params.number1 + params.number2;
+    }
+}
+const exampleService = new ExampleService();
+
+export { ExampleService, exampleService };

package/lib/services/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var services_keyring_service = require('./keyring/service.js');
+var services_dock_service = require('./dock/service.js');
+var services_substrate_service = require('./substrate/service.js');
+var services_wallet_service = require('./wallet/service.js');
+var services_polkadot_service = require('./polkadot/service.js');
+var services_utilCrypto_service = require('./util-crypto/service.js');
+var services_storage_service = require('./storage/service.js');
+var services_dids_service = require('./dids/service.js');
+var services_credential_service = require('./credential/service.js');
+var services_relayService_service = require('./relay-service/service.js');
+var services_pex_service = require('./pex/service.js');
+var services_trustRegistry_service = require('./trust-registry/service.js');
+require('@polkadot/keyring');
+require('@polkadot/util-crypto');
+require('./keyring/configs.js');
+require('assert');
+require('../core/validation.js');
+require('bignumber.js');
+require('../types.js');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../core/logger.js');
+require('../modules/event-manager.js');
+require('./dock/configs.js');
+require('bn.js');
+require('../core/format-utils.js');
+require('./substrate/api-utils.js');
+require('./substrate/configs.js');
+require('uuid');
+require('../wallet/memory-storage-wallet.js');
+require('@docknetwork/universal-wallet/storage-wallet');
+require('../wallet/memory-storage-interface.js');
+require('@docknetwork/universal-wallet/storage/storage-interface');
+require('../wallet/rpc-storage-wallet.js');
+require('../wallet/rpc-storage-interface.js');
+require('./wallet/configs.js');
+require('@polkadot/ui-shared/cjs/icons/index');
+require('./polkadot/configs.js');
+require('@polkadot/util');
+require('./util-crypto/configs.js');
+require('@docknetwork/wallet-sdk-dids/src');
+require('./dids/config.js');
+require('@docknetwork/sdk/utils/did');
+require('@docknetwork/sdk/public-keys');
+require('../core/polkadot-utils.js');
+require('@polkadot/keyring/pair/decode');
+require('@docknetwork/sdk/utils/misc');
+require('base58-universal');
+require('@docknetwork/universal-wallet/methods/keypairs');
+require('./credential/config.js');
+require('@docknetwork/crypto-wasm-ts');
+require('@docknetwork/sdk/verifiable-credential');
+require('@docknetwork/sdk/utils/vc/helpers');
+require('@docknetwork/sdk/verifiable-presentation');
+require('@docknetwork/sdk/presentation');
+require('@docknetwork/sdk/utils/vc/credentials');
+require('@sphereon/pex');
+require('./credential/utils.js');
+require('@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022');
+require('./credential/bound-check.js');
+require('@docknetwork/crypto-wasm-ts/lib/legosnark');
+require('base64url');
+require('./credential/pex-helpers.js');
+require('@astronautlabs/jsonpath');
+require('./credential/bbs-revocation.js');
+require('./relay-service/configs.js');
+require('@docknetwork/wallet-sdk-relay-service/src');
+require('./pex/config.js');
+require('./trust-registry/configs.js');
+require('@docknetwork/sdk/utils/did/typed-did/helpers');
+require('crypto');
+
+var services = [
+  services_keyring_service.keyringService,
+  services_dock_service.dockService,
+  services_substrate_service.substrateService,
+  services_wallet_service.walletService,
+  services_polkadot_service.polkadotService,
+  services_utilCrypto_service.utilCryptoService,
+  services_storage_service.storageService,
+  services_dids_service.didService,
+  services_credential_service.credentialService,
+  services_relayService_service.relayService,
+  services_pex_service.pexService,
+  services_trustRegistry_service.trustRegistryService,
+];
+
+module.exports = services;

package/lib/services/index.mjs

@@ -0,0 +1,90 @@
+import { keyringService } from './keyring/service.mjs';
+import { dockService } from './dock/service.mjs';
+import { substrateService } from './substrate/service.mjs';
+import { walletService } from './wallet/service.mjs';
+import { polkadotService } from './polkadot/service.mjs';
+import { utilCryptoService } from './util-crypto/service.mjs';
+import { storageService } from './storage/service.mjs';
+import { didService } from './dids/service.mjs';
+import { credentialService } from './credential/service.mjs';
+import { relayService } from './relay-service/service.mjs';
+import { pexService } from './pex/service.mjs';
+import { trustRegistryService } from './trust-registry/service.mjs';
+import '@polkadot/keyring';
+import '@polkadot/util-crypto';
+import './keyring/configs.mjs';
+import 'assert';
+import '../core/validation.mjs';
+import 'bignumber.js';
+import '../types.mjs';
+import '@docknetwork/sdk';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../core/logger.mjs';
+import '../modules/event-manager.mjs';
+import './dock/configs.mjs';
+import 'bn.js';
+import '../core/format-utils.mjs';
+import './substrate/api-utils.mjs';
+import './substrate/configs.mjs';
+import 'uuid';
+import '../wallet/memory-storage-wallet.mjs';
+import '@docknetwork/universal-wallet/storage-wallet';
+import '../wallet/memory-storage-interface.mjs';
+import '@docknetwork/universal-wallet/storage/storage-interface';
+import '../wallet/rpc-storage-wallet.mjs';
+import '../wallet/rpc-storage-interface.mjs';
+import './wallet/configs.mjs';
+import '@polkadot/ui-shared/cjs/icons/index';
+import './polkadot/configs.mjs';
+import '@polkadot/util';
+import './util-crypto/configs.mjs';
+import '@docknetwork/wallet-sdk-dids/src';
+import './dids/config.mjs';
+import '@docknetwork/sdk/utils/did';
+import '@docknetwork/sdk/public-keys';
+import '../core/polkadot-utils.mjs';
+import '@polkadot/keyring/pair/decode';
+import '@docknetwork/sdk/utils/misc';
+import 'base58-universal';
+import '@docknetwork/universal-wallet/methods/keypairs';
+import './credential/config.mjs';
+import '@docknetwork/crypto-wasm-ts';
+import '@docknetwork/sdk/verifiable-credential';
+import '@docknetwork/sdk/utils/vc/helpers';
+import '@docknetwork/sdk/verifiable-presentation';
+import '@docknetwork/sdk/presentation';
+import '@docknetwork/sdk/utils/vc/credentials';
+import '@sphereon/pex';
+import './credential/utils.mjs';
+import '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
+import './credential/bound-check.mjs';
+import '@docknetwork/crypto-wasm-ts/lib/legosnark';
+import 'base64url';
+import './credential/pex-helpers.mjs';
+import '@astronautlabs/jsonpath';
+import './credential/bbs-revocation.mjs';
+import './relay-service/configs.mjs';
+import '@docknetwork/wallet-sdk-relay-service/src';
+import './pex/config.mjs';
+import './trust-registry/configs.mjs';
+import '@docknetwork/sdk/utils/did/typed-did/helpers';
+import 'crypto';
+
+var services = [
+  keyringService,
+  dockService,
+  substrateService,
+  walletService,
+  polkadotService,
+  utilCryptoService,
+  storageService,
+  didService,
+  credentialService,
+  relayService,
+  pexService,
+  trustRegistryService,
+];
+
+export { services as default };

package/lib/services/keyring/configs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var core_validation = require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+// @ts-nocheck
+const validation = {
+    addFromJson({ jsonData, password }) {
+        assert__default["default"](typeof jsonData === 'object', 'invalid jsonData');
+        assert__default["default"](typeof password === 'string', 'invalid password');
+    },
+    initialize({ ss58Format, type }) {
+        assert__default["default"](typeof ss58Format === 'number', 'invalid ss58Format');
+        if (type) {
+            core_validation.assertKeyType(type);
+        }
+    },
+    addFromMnemonic({ mnemonic, meta, type }) {
+        assert__default["default"](typeof mnemonic === 'string', 'invalid mnemonic');
+        if (type) {
+            core_validation.assertKeyType(type);
+        }
+        if (meta) {
+            assert__default["default"](typeof meta === 'object', 'invalid meta');
+        }
+    },
+    getKeyringPair(params) {
+        const { mnemonic, derivePath, meta, type } = params;
+        assert__default["default"](!params.keyPairType, 'invalid parameter keyPairType, you should use type instead');
+        assert__default["default"](typeof mnemonic === 'string', 'invalid mnemonic');
+        if (derivePath) {
+            assert__default["default"](typeof derivePath === 'string', 'invalid derivePath');
+        }
+        if (type) {
+            core_validation.assertKeyType(type);
+        }
+        if (meta) {
+            assert__default["default"](typeof meta === 'object', 'invalid meta');
+        }
+    },
+    signData(params) {
+        assert__default["default"](!!params.keyPair, 'invalid keypair');
+        assert__default["default"](!!params.data, 'invalid data');
+    },
+};
+validation.addressFromUri = validation.getKeyringPair;
+const serviceName = 'keyring';
+
+exports.serviceName = serviceName;
+exports.validation = validation;

package/lib/services/keyring/configs.mjs

@@ -0,0 +1,49 @@
+import assert from 'assert';
+import { assertKeyType } from '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+// @ts-nocheck
+const validation = {
+    addFromJson({ jsonData, password }) {
+        assert(typeof jsonData === 'object', 'invalid jsonData');
+        assert(typeof password === 'string', 'invalid password');
+    },
+    initialize({ ss58Format, type }) {
+        assert(typeof ss58Format === 'number', 'invalid ss58Format');
+        if (type) {
+            assertKeyType(type);
+        }
+    },
+    addFromMnemonic({ mnemonic, meta, type }) {
+        assert(typeof mnemonic === 'string', 'invalid mnemonic');
+        if (type) {
+            assertKeyType(type);
+        }
+        if (meta) {
+            assert(typeof meta === 'object', 'invalid meta');
+        }
+    },
+    getKeyringPair(params) {
+        const { mnemonic, derivePath, meta, type } = params;
+        assert(!params.keyPairType, 'invalid parameter keyPairType, you should use type instead');
+        assert(typeof mnemonic === 'string', 'invalid mnemonic');
+        if (derivePath) {
+            assert(typeof derivePath === 'string', 'invalid derivePath');
+        }
+        if (type) {
+            assertKeyType(type);
+        }
+        if (meta) {
+            assert(typeof meta === 'object', 'invalid meta');
+        }
+    },
+    signData(params) {
+        assert(!!params.keyPair, 'invalid keypair');
+        assert(!!params.data, 'invalid data');
+    },
+};
+validation.addressFromUri = validation.getKeyringPair;
+const serviceName = 'keyring';
+
+export { serviceName, validation };

package/lib/services/keyring/index.android.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_keyring_serviceRpc = require('./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');
+require('./configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+const keyringService = new services_keyring_serviceRpc.KeyringServiceRpc();
+
+exports.keyringService = keyringService;

package/lib/services/keyring/index.android.mjs

@@ -0,0 +1,18 @@
+import { KeyringServiceRpc } from './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';
+import './configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+const keyringService = new KeyringServiceRpc();
+
+export { keyringService };

package/lib/services/keyring/index.ios.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_keyring_serviceRpc = require('./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');
+require('./configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+const keyringService = new services_keyring_serviceRpc.KeyringServiceRpc();
+
+exports.keyringService = keyringService;

package/lib/services/keyring/index.ios.mjs

@@ -0,0 +1,18 @@
+import { KeyringServiceRpc } from './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';
+import './configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+const keyringService = new KeyringServiceRpc();
+
+export { keyringService };