@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/util-crypto/configs.mjs

@@ -0,0 +1,24 @@
+import assert from 'assert';
+import { assertAddress } from '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+// @ts-nocheck
+const validation = {
+    deriveValidate(uri) {
+        assert(!!uri, 'uri is required');
+    },
+    isAddressValid(address) {
+        assertAddress(address);
+    },
+    mnemonicGenerate(numWords) {
+        if (numWords) {
+            assert(typeof numWords === 'number', 'invalid number of words');
+        }
+    },
+    mnemonicValidate(phrase) {
+        assert(typeof phrase === 'string', 'invalid mnemonic phrase');
+    },
+};
+
+export { validation };

package/lib/services/util-crypto/index.android.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_utilCrypto_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 utilCryptoService = new services_utilCrypto_serviceRpc.UtilCryptoServiceRpc();
+
+exports.utilCryptoService = utilCryptoService;

package/lib/services/util-crypto/index.android.mjs

@@ -0,0 +1,18 @@
+import { UtilCryptoServiceRpc } 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 utilCryptoService = new UtilCryptoServiceRpc();
+
+export { utilCryptoService };

package/lib/services/util-crypto/index.ios.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_utilCrypto_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 utilCryptoService = new services_utilCrypto_serviceRpc.UtilCryptoServiceRpc();
+
+exports.utilCryptoService = utilCryptoService;

package/lib/services/util-crypto/index.ios.mjs

@@ -0,0 +1,18 @@
+import { UtilCryptoServiceRpc } 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 utilCryptoService = new UtilCryptoServiceRpc();
+
+export { utilCryptoService };

package/lib/services/util-crypto/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_utilCrypto_service = require('./service.js');
+require('@polkadot/keyring');
+require('@polkadot/util');
+require('@polkadot/util-crypto');
+require('assert');
+require('./configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+
+
+exports.utilCryptoService = services_utilCrypto_service.utilCryptoService;

package/lib/services/util-crypto/index.mjs

@@ -0,0 +1,9 @@
+export { utilCryptoService } from './service.mjs';
+import '@polkadot/keyring';
+import '@polkadot/util';
+import '@polkadot/util-crypto';
+import 'assert';
+import './configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';

package/lib/services/util-crypto/service-rpc.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_utilCrypto_configs = require('./configs.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('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+class UtilCryptoServiceRpc extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super('utilCrypto');
+  }
+
+  mnemonicGenerate(numWords        )               {
+    services_utilCrypto_configs.validation.mnemonicGenerate(numWords);
+
+    return this.call('mnemonicGenerate', numWords);
+  }
+
+  mnemonicValidate(phrase        )               {
+    services_utilCrypto_configs.validation.mnemonicValidate(phrase);
+
+    return this.call('mnemonicValidate', phrase);
+  }
+
+  cryptoWaitReady()               {
+    return this.call('cryptoWaitReady');
+  }
+
+  cryptoIsReady()               {
+    return this.call('cryptoIsReady');
+  }
+
+  isAddressValid(address        )               {
+    services_utilCrypto_configs.validation.deriveValidate(address);
+
+    return this.call('isAddressValid', address);
+  }
+
+  deriveValidate(uri        )               {
+    services_utilCrypto_configs.validation.deriveValidate(uri);
+    return this.call('deriveValidate', uri);
+  }
+
+  isBase64(value        )                   {
+    return this.call('isBase64', value);
+  }
+
+  getAddressPrefix(params     )                         {
+    return this.call('getAddressPrefix', params);
+  }
+}
+
+exports.UtilCryptoServiceRpc = UtilCryptoServiceRpc;

package/lib/services/util-crypto/service-rpc.mjs

@@ -0,0 +1,60 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { validation } from './configs.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 '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+class UtilCryptoServiceRpc extends RpcService {
+  constructor() {
+    super('utilCrypto');
+  }
+
+  mnemonicGenerate(numWords        )               {
+    validation.mnemonicGenerate(numWords);
+
+    return this.call('mnemonicGenerate', numWords);
+  }
+
+  mnemonicValidate(phrase        )               {
+    validation.mnemonicValidate(phrase);
+
+    return this.call('mnemonicValidate', phrase);
+  }
+
+  cryptoWaitReady()               {
+    return this.call('cryptoWaitReady');
+  }
+
+  cryptoIsReady()               {
+    return this.call('cryptoIsReady');
+  }
+
+  isAddressValid(address        )               {
+    validation.deriveValidate(address);
+
+    return this.call('isAddressValid', address);
+  }
+
+  deriveValidate(uri        )               {
+    validation.deriveValidate(uri);
+    return this.call('deriveValidate', uri);
+  }
+
+  isBase64(value        )                   {
+    return this.call('isBase64', value);
+  }
+
+  getAddressPrefix(params     )                         {
+    return this.call('getAddressPrefix', params);
+  }
+}
+
+export { UtilCryptoServiceRpc };

package/lib/services/util-crypto/service.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Keyring = require('@polkadot/keyring');
+var util = require('@polkadot/util');
+var utilCrypto = require('@polkadot/util-crypto');
+var assert = require('assert');
+var services_utilCrypto_configs = require('./configs.js');
+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
+class UtilCryptoService {
+    rpcMethods = [
+        UtilCryptoService.prototype.mnemonicGenerate,
+        UtilCryptoService.prototype.mnemonicValidate,
+        UtilCryptoService.prototype.cryptoWaitReady,
+        UtilCryptoService.prototype.cryptoIsReady,
+        UtilCryptoService.prototype.isAddressValid,
+        UtilCryptoService.prototype.deriveValidate,
+        UtilCryptoService.prototype.isBase64,
+        UtilCryptoService.prototype.getAddressPrefix,
+    ];
+    constructor() {
+        this.name = 'utilCrypto';
+    }
+    mnemonicGenerate(numWords) {
+        services_utilCrypto_configs.validation.mnemonicGenerate(numWords);
+        return utilCrypto.mnemonicGenerate(numWords);
+    }
+    isBase64(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        const decoded1 = Buffer.from(value, 'base64').toString('utf8');
+        const encoded2 = Buffer.from(decoded1, 'binary').toString('base64');
+        return value === encoded2;
+    }
+    mnemonicValidate(phrase) {
+        services_utilCrypto_configs.validation.mnemonicValidate(phrase);
+        return utilCrypto.mnemonicValidate(phrase);
+    }
+    cryptoWaitReady() {
+        return utilCrypto.cryptoWaitReady();
+    }
+    cryptoIsReady(...args) {
+        return utilCrypto.cryptoIsReady();
+    }
+    getAddressPrefix(params) {
+        const { address, startPrefix, endPrefix } = params;
+        for (let prefix = startPrefix; prefix <= endPrefix; prefix++) {
+            try {
+                const decoded = Keyring.decodeAddress(address);
+                const reencoded = Keyring.encodeAddress(decoded, prefix);
+                if (reencoded === address) {
+                    return prefix;
+                }
+            }
+            catch (err) {
+                // Ignore invalid prefixes
+            }
+        }
+        return null;
+    }
+    isAddressValid(address) {
+        services_utilCrypto_configs.validation.isAddressValid(address);
+        try {
+            Keyring.encodeAddress(util.isHex(address) ? util.hexToU8a(address) : Keyring.decodeAddress(address));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    deriveValidate(uri) {
+        services_utilCrypto_configs.validation.deriveValidate(uri);
+        const { password, path } = utilCrypto.keyExtractSuri(uri);
+        let result = {};
+        assert__default["default"](path.length, 'invalid derive path');
+        // show a warning in case the password contains an unintended / character
+        if (password && password.includes('/')) {
+            result = { warning: 'slash password detected' };
+        }
+        return result;
+    }
+}
+const utilCryptoService = new UtilCryptoService();
+
+exports.UtilCryptoService = UtilCryptoService;
+exports.utilCryptoService = utilCryptoService;

package/lib/services/util-crypto/service.mjs

@@ -0,0 +1,87 @@
+import { decodeAddress, encodeAddress } from '@polkadot/keyring';
+import { isHex, hexToU8a } from '@polkadot/util';
+import { mnemonicGenerate, mnemonicValidate, cryptoWaitReady, cryptoIsReady, keyExtractSuri } from '@polkadot/util-crypto';
+import assert from 'assert';
+import { validation } from './configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+// @ts-nocheck
+class UtilCryptoService {
+    rpcMethods = [
+        UtilCryptoService.prototype.mnemonicGenerate,
+        UtilCryptoService.prototype.mnemonicValidate,
+        UtilCryptoService.prototype.cryptoWaitReady,
+        UtilCryptoService.prototype.cryptoIsReady,
+        UtilCryptoService.prototype.isAddressValid,
+        UtilCryptoService.prototype.deriveValidate,
+        UtilCryptoService.prototype.isBase64,
+        UtilCryptoService.prototype.getAddressPrefix,
+    ];
+    constructor() {
+        this.name = 'utilCrypto';
+    }
+    mnemonicGenerate(numWords) {
+        validation.mnemonicGenerate(numWords);
+        return mnemonicGenerate(numWords);
+    }
+    isBase64(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        const decoded1 = Buffer.from(value, 'base64').toString('utf8');
+        const encoded2 = Buffer.from(decoded1, 'binary').toString('base64');
+        return value === encoded2;
+    }
+    mnemonicValidate(phrase) {
+        validation.mnemonicValidate(phrase);
+        return mnemonicValidate(phrase);
+    }
+    cryptoWaitReady() {
+        return cryptoWaitReady();
+    }
+    cryptoIsReady(...args) {
+        return cryptoIsReady();
+    }
+    getAddressPrefix(params) {
+        const { address, startPrefix, endPrefix } = params;
+        for (let prefix = startPrefix; prefix <= endPrefix; prefix++) {
+            try {
+                const decoded = decodeAddress(address);
+                const reencoded = encodeAddress(decoded, prefix);
+                if (reencoded === address) {
+                    return prefix;
+                }
+            }
+            catch (err) {
+                // Ignore invalid prefixes
+            }
+        }
+        return null;
+    }
+    isAddressValid(address) {
+        validation.isAddressValid(address);
+        try {
+            encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    deriveValidate(uri) {
+        validation.deriveValidate(uri);
+        const { password, path } = keyExtractSuri(uri);
+        let result = {};
+        assert(path.length, 'invalid derive path');
+        // show a warning in case the password contains an unintended / character
+        if (password && password.includes('/')) {
+            result = { warning: 'slash password detected' };
+        }
+        return result;
+    }
+}
+const utilCryptoService = new UtilCryptoService();
+
+export { UtilCryptoService, utilCryptoService };

package/lib/services/wallet/configs.js

@@ -0,0 +1,95 @@
+'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
+function assertContent(content) {
+    assert__default["default"](typeof content === 'object', 'invalid wallet content');
+    assert__default["default"](typeof content.id === 'string', `invalid content id ${content.id}`);
+    assert__default["default"](typeof content.type === 'string', `invalid content type ${content.type}`);
+}
+const validation = {
+    getDocumentById(id) {
+        assert__default["default"](typeof id === 'string', 'invalid documentId');
+        assert__default["default"](!!id, 'documentId is required');
+    },
+    resolveCorrelations(address) {
+        assert__default["default"](typeof address === 'string', 'invalid documentId');
+        assert__default["default"](!!address, 'documentId is required');
+    },
+    exportAccount({ address, password }) {
+        core_validation.assertAddress(address);
+        core_validation.assertPassword(password);
+    },
+    create({ walletId }) {
+        assert__default["default"](typeof walletId === 'string', `invalid walletId ${walletId}`);
+    },
+    lock(password) {
+        core_validation.assertPassword(password);
+    },
+    unlock(password) {
+        core_validation.assertPassword(password);
+    },
+    add(params) {
+        assertContent(params);
+    },
+    remove(id) {
+        assert__default["default"](typeof id === 'string', 'invalid documentId');
+        assert__default["default"](!!id, 'documentId is required');
+    },
+    update(params) {
+        assertContent(params);
+    },
+    query(params) {
+        assert__default["default"](typeof params === 'object', 'invalid query');
+    },
+    exportWallet(password) {
+        core_validation.assertPassword(password);
+    },
+    getDocumentsFromEncryptedWallet({ encryptedJSONWallet, password, }) {
+        assert__default["default"](typeof encryptedJSONWallet === 'object', `invalid json data: ${encryptedJSONWallet}`);
+        core_validation.assertPassword(password);
+    },
+    importWallet({ json, password }) {
+        assert__default["default"](typeof json === 'object', `invalid json data: ${json}`);
+        core_validation.assertPassword(password);
+    },
+    exportDocuments({ documents, password }) {
+        assert__default["default"](Array.isArray(documents), 'Invalid Documents');
+        assert__default["default"](documents.length > 0, 'Cannot export empty documents');
+        for (const document of documents) {
+            assert__default["default"](typeof document.id === 'string', 'Document ID is required');
+            assert__default["default"](typeof document['@context'] !== 'undefined', '@context is required');
+        }
+        core_validation.assertPassword(password);
+    },
+    createAccountDocuments(params) {
+        const { name, json, password, mnemonic, type } = params;
+        // Property derivationPath was replaced by derivePath
+        assert__default["default"](!params.derivationPath, 'invalid parameter derivationPath, it should be derivePath instead');
+        assert__default["default"](typeof name === 'string', `invalid account name: ${name}`);
+        if (json) {
+            assert__default["default"](typeof json === 'object', `invalid json: ${password}`);
+            assert__default["default"](typeof password === 'string', `invalid password: ${password}`);
+        }
+        else {
+            assert__default["default"](typeof mnemonic === 'string', `invalid mnemonic: ${mnemonic}`);
+        }
+        if (type) {
+            core_validation.assertKeyType(type);
+        }
+    },
+};
+const serviceName = 'wallet';
+
+exports.serviceName = serviceName;
+exports.validation = validation;

package/lib/services/wallet/configs.mjs

@@ -0,0 +1,86 @@
+import assert from 'assert';
+import { assertAddress, assertPassword, assertKeyType } from '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+
+// @ts-nocheck
+function assertContent(content) {
+    assert(typeof content === 'object', 'invalid wallet content');
+    assert(typeof content.id === 'string', `invalid content id ${content.id}`);
+    assert(typeof content.type === 'string', `invalid content type ${content.type}`);
+}
+const validation = {
+    getDocumentById(id) {
+        assert(typeof id === 'string', 'invalid documentId');
+        assert(!!id, 'documentId is required');
+    },
+    resolveCorrelations(address) {
+        assert(typeof address === 'string', 'invalid documentId');
+        assert(!!address, 'documentId is required');
+    },
+    exportAccount({ address, password }) {
+        assertAddress(address);
+        assertPassword(password);
+    },
+    create({ walletId }) {
+        assert(typeof walletId === 'string', `invalid walletId ${walletId}`);
+    },
+    lock(password) {
+        assertPassword(password);
+    },
+    unlock(password) {
+        assertPassword(password);
+    },
+    add(params) {
+        assertContent(params);
+    },
+    remove(id) {
+        assert(typeof id === 'string', 'invalid documentId');
+        assert(!!id, 'documentId is required');
+    },
+    update(params) {
+        assertContent(params);
+    },
+    query(params) {
+        assert(typeof params === 'object', 'invalid query');
+    },
+    exportWallet(password) {
+        assertPassword(password);
+    },
+    getDocumentsFromEncryptedWallet({ encryptedJSONWallet, password, }) {
+        assert(typeof encryptedJSONWallet === 'object', `invalid json data: ${encryptedJSONWallet}`);
+        assertPassword(password);
+    },
+    importWallet({ json, password }) {
+        assert(typeof json === 'object', `invalid json data: ${json}`);
+        assertPassword(password);
+    },
+    exportDocuments({ documents, password }) {
+        assert(Array.isArray(documents), 'Invalid Documents');
+        assert(documents.length > 0, 'Cannot export empty documents');
+        for (const document of documents) {
+            assert(typeof document.id === 'string', 'Document ID is required');
+            assert(typeof document['@context'] !== 'undefined', '@context is required');
+        }
+        assertPassword(password);
+    },
+    createAccountDocuments(params) {
+        const { name, json, password, mnemonic, type } = params;
+        // Property derivationPath was replaced by derivePath
+        assert(!params.derivationPath, 'invalid parameter derivationPath, it should be derivePath instead');
+        assert(typeof name === 'string', `invalid account name: ${name}`);
+        if (json) {
+            assert(typeof json === 'object', `invalid json: ${password}`);
+            assert(typeof password === 'string', `invalid password: ${password}`);
+        }
+        else {
+            assert(typeof mnemonic === 'string', `invalid mnemonic: ${mnemonic}`);
+        }
+        if (type) {
+            assertKeyType(type);
+        }
+    },
+};
+const serviceName = 'wallet';
+
+export { serviceName, validation };

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_wallet_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 walletService = new services_wallet_serviceRpc.WalletServiceRpc();
+
+exports.walletService = walletService;

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

@@ -0,0 +1,18 @@
+import { WalletServiceRpc } 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 walletService = new WalletServiceRpc();
+
+export { walletService };