@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/lib/services/test-utils.mjs

@@ -1,51 +1,9 @@
-import { cryptoWaitReady } from '@polkadot/util-crypto';
 import assert from 'assert';
-import BigNumber from 'bignumber.js';
-import { DOCK_TOKEN_UNIT } from '../core/format-utils.mjs';
-import { TestFixtures } from '../fixtures.mjs';
 import { NetworkManager } from '../modules/network-manager.mjs';
-import { keyringService } from './keyring/service.mjs';
 import 'json-rpc-2.0';
 import '../core/crypto.mjs';
 import '../core/logger.mjs';
-import { walletService } from './wallet/service.mjs';
-import Keyring from '@polkadot/keyring';
-import { blockchainService } from './blockchain/service.mjs';
-import '../core/validation.mjs';
-import '../types.mjs';
-import './keyring/configs.mjs';
 import 'crypto';
-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 './storage/service.mjs';
-import './wallet/configs.mjs';
-import '@cosmjs/proto-signing';
-import '@docknetwork/cheqd-blockchain-api';
-import '@docknetwork/cheqd-blockchain-modules';
-import '@docknetwork/credential-sdk/modules';
-import '@docknetwork/credential-sdk/resolver';
-import '@docknetwork/crypto-wasm-ts/lib/index';
-import '@docknetwork/dock-blockchain-api';
-import '@docknetwork/dock-blockchain-modules';
-import 'events';
-import '../modules/event-manager.mjs';
-import './util-crypto/service.mjs';
-import '@polkadot/util';
-import './util-crypto/configs.mjs';
-import '@docknetwork/credential-sdk/types';
-
-async function initializeWalletService() {
-  await cryptoWaitReady();
-  await keyringService.initialize({
-    ss58Format: 21,
-  });
-  await walletService.create('test-wallet', 'memory');
-}
 
 const TEST_FEE_AMOUNT = 2.48;
 const API_MOCK_DISABLED = process.env.API_MOCK_DISABLED === 'true';
@@ -63,105 +21,6 @@ const TEST_SCHEMA_METADATA = {
   },
 };
 
-let mockTransactionError;
-
-const setMockTransactionError = error => {
-  mockTransactionError = error;
-};
-
-async function mockDockService() {
-  await cryptoWaitReady();
-
-  await keyringService.initialize({
-    ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-  });
-
-  let sdkMock;
-
-  if (API_MOCK_DISABLED) {
-    return blockchainService.init({
-      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
-    });
-  } else {
-    sdkMock = mockDockSdkConnection();
-    await blockchainService.init({
-      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
-    });
-  }
-
-  const _dockSdk = blockchainService.dock;
-
-  blockchainService.isDockReady = true;
-
-  blockchainService.dock = {
-    api: {
-      events: {
-        system: {
-          ExtrinsicFailed: {
-            is: event => !!mockTransactionError,
-          },
-        },
-      },
-      query: {
-        system: {
-          account: jest.fn().mockImplementation(() => ({
-            data: {
-              free: BigNumber(TestFixtures.account1.balance * DOCK_TOKEN_UNIT),
-            },
-          })),
-        },
-      },
-      revocation: {
-        getIsRevoked: jest.fn().mockImplementation(() => false),
-      },
-      tx: {
-        balances: {
-          transfer: jest.fn().mockImplementation(() => ({
-            paymentInfo: () => ({
-              partialFee: BigNumber(TEST_FEE_AMOUNT * DOCK_TOKEN_UNIT),
-            }),
-            signAndSend: (account, callback) => {
-              callback({
-                status: {
-                  isInBlock: true,
-                  isFinalized: true,
-                  toHex: () => 'hash',
-                },
-                events: [
-                  {
-                    event: {
-                      data: [mockTransactionError],
-                    },
-                  },
-                ],
-              });
-
-              return Promise.resolve({});
-            },
-          })),
-        },
-      },
-    },
-    trustRegistry: {
-      registriesInfo: jest.fn().mockImplementation(() => TEST_TRUST_REGISTRIES),
-      registrySchemasMetadata: jest
-        .fn()
-        .mockImplementation(() => TEST_SCHEMA_METADATA),
-    },
-    init: jest.fn().mockImplementation(() => Promise.resolve({})),
-    disconnect: jest.fn(),
-    setAccount: jest.fn(),
-  };
-
-  return () => {
-    blockchainService.dock = _dockSdk;
-    if (sdkMock) {
-      sdkMock.clear();
-    }
-    blockchainService.disconnect();
-  };
-}
-
 let walletCreated;
 
 async function setupTestWallet() {
@@ -171,101 +30,9 @@ async function setupTestWallet() {
 
   NetworkManager.getInstance().setNetworkId('testnet');
 
-  await cryptoWaitReady();
-  await keyringService.initialize({
-    ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-  });
-  await walletService.create({
-    walletId: 'test-wallet',
-    type: 'memory',
-  });
-  await walletService.createAccountDocuments({
-    mnemonic: TestFixtures.account1.mnemonic,
-    name: TestFixtures.account1.name,
-  });
-  await walletService.createAccountDocuments({
-    mnemonic: TestFixtures.account2.mnemonic,
-    name: TestFixtures.account2.name,
-  });
-
   walletCreated = true;
 }
 
-function mockDockSdkConnection(connectionError) {
-  const result = 'result';
-  const dock = blockchainService.dock;
-  const mocks = [
-    jest.spyOn(dock, 'init').mockImplementation(() => {
-      if (connectionError) {
-        return Promise.reject(connectionError);
-      }
-
-      return Promise.resolve(result);
-    }),
-    jest.spyOn(dock, 'disconnect').mockReturnValue(Promise.resolve(true)),
-  ];
-
-  let currentAccount;
-
-  blockchainService.dock = {
-    ...dock,
-    setAccount(account) {
-      currentAccount = account;
-    },
-    did: {
-      new: () => {
-        if (
-          currentAccount &&
-          currentAccount.address === TestFixtures.noBalanceAccount.address
-        ) {
-          throw new Error(
-            '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low',
-          );
-        }
-        return {
-          txHash: 'hash',
-        };
-      },
-      getDocument: () => ({
-        '@context': ['https://www.w3.org/ns/did/v1'],
-        assertionMethod: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        authentication: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        capabilityInvocation: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        controller: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-        ],
-        id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-        publicKey: [
-          {
-            controller:
-              'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-            id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-            publicKeyBase58: '8UDojkFBh5RopLKZredz8uVZV5U579voUwQFyYDmgBM3',
-            type: 'Sr25519VerificationKey2020',
-          },
-        ],
-      }),
-    },
-    keyring: {
-      createFromPair: jest.fn(() => {
-        const kr = new Keyring();
-        return kr.createFromUri('//Alice');
-      }),
-    },
-  };
-
-  return {
-    result,
-    clear: () => mocks.forEach(mock => mock.mockClear()),
-  };
-}
-
 async function getPromiseError(func) {
   try {
     return await func();
@@ -314,4 +81,4 @@ function assertRpcService(
   });
 }
 
-export { API_MOCK_DISABLED, TEST_FEE_AMOUNT, TEST_SCHEMA_METADATA, TEST_TRUST_REGISTRIES, assertRpcService, getPromiseError, initializeWalletService, mockDockSdkConnection, mockDockService, setMockTransactionError, setupTestWallet };
+export { API_MOCK_DISABLED, TEST_FEE_AMOUNT, TEST_SCHEMA_METADATA, TEST_TRUST_REGISTRIES, assertRpcService, getPromiseError, setupTestWallet };

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

@@ -3,9 +3,6 @@
 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 }; }
 
@@ -13,12 +10,6 @@ var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
 
 // @ts-nocheck
 const validation = {
-    deriveValidate(uri) {
-        assert__default["default"](!!uri, 'uri is required');
-    },
-    isAddressValid(address) {
-        core_validation.assertAddress(address);
-    },
     mnemonicGenerate(numWords) {
         if (numWords) {
             assert__default["default"](typeof numWords === 'number', 'invalid number of words');
@@ -27,9 +18,6 @@ const validation = {
     mnemonicToMiniSecret(phrase) {
         assert__default["default"](typeof phrase === 'string', 'invalid mnemonic phrase');
     },
-    mnemonicValidate(phrase) {
-        assert__default["default"](typeof phrase === 'string', 'invalid mnemonic phrase');
-    },
 };
 
 exports.validation = validation;

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

@@ -1,16 +1,7 @@
 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');
@@ -19,9 +10,6 @@ const validation = {
     mnemonicToMiniSecret(phrase) {
         assert(typeof phrase === 'string', 'invalid mnemonic phrase');
     },
-    mnemonicValidate(phrase) {
-        assert(typeof phrase === 'string', 'invalid mnemonic phrase');
-    },
 };
 
 export { validation };

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

@@ -13,9 +13,6 @@ 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();
 

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

@@ -9,9 +9,6 @@ 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();
 

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

@@ -13,9 +13,6 @@ 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();
 

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

@@ -9,9 +9,6 @@ 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();
 

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

@@ -3,14 +3,11 @@
 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('@docknetwork/credential-sdk/utils');
+require('@scure/bip39');
+require('@scure/bip39/wordlists/english');
 require('./configs.js');
-require('../../core/validation.js');
-require('bignumber.js');
-require('../../types.js');
+require('assert');
 
 
 

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

@@ -1,9 +1,6 @@
 export { utilCryptoService } from './service.mjs';
-import '@polkadot/keyring';
-import '@polkadot/util';
-import '@polkadot/util-crypto';
-import 'assert';
+import '@docknetwork/credential-sdk/utils';
+import '@scure/bip39';
+import '@scure/bip39/wordlists/english';
 import './configs.mjs';
-import '../../core/validation.mjs';
-import 'bignumber.js';
-import '../../types.mjs';
+import 'assert';

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

@@ -12,9 +12,6 @@ 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() {
@@ -33,26 +30,6 @@ class UtilCryptoServiceRpc extends services_rpcServiceClient.RpcService {
     return this.call('mnemonicToMiniSecret', phrase);
   }
 
-  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);

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

@@ -8,9 +8,6 @@ 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() {
@@ -29,26 +26,6 @@ class UtilCryptoServiceRpc extends RpcService {
     return this.call('mnemonicToMiniSecret', phrase);
   }
 
-  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);

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

@@ -2,97 +2,104 @@
 
 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 utils = require('@docknetwork/credential-sdk/utils');
+var bip39 = require('@scure/bip39');
+var english = require('@scure/bip39/wordlists/english');
 var services_utilCrypto_configs = require('./configs.js');
-require('../../core/validation.js');
-require('bignumber.js');
-require('../../types.js');
+require('assert');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
 
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var bip39__namespace = /*#__PURE__*/_interopNamespace(bip39);
 
 // @ts-nocheck
 class UtilCryptoService {
     rpcMethods = [
         UtilCryptoService.prototype.mnemonicGenerate,
         UtilCryptoService.prototype.mnemonicToMiniSecret,
-        UtilCryptoService.prototype.mnemonicValidate,
-        UtilCryptoService.prototype.cryptoWaitReady,
-        UtilCryptoService.prototype.cryptoIsReady,
-        UtilCryptoService.prototype.isAddressValid,
-        UtilCryptoService.prototype.deriveValidate,
         UtilCryptoService.prototype.isBase64,
-        UtilCryptoService.prototype.getAddressPrefix,
+        UtilCryptoService.prototype.hexToString,
     ];
     constructor() {
         this.name = 'utilCrypto';
     }
-    mnemonicGenerate(numWords) {
+    mnemonicGenerate(numWords = 12) {
         services_utilCrypto_configs.validation.mnemonicGenerate(numWords);
-        return utilCrypto.mnemonicGenerate(numWords);
+        // @scure/bip39 uses strength in bits, not number of words
+        // 12 words = 128 bits, 15 words = 160 bits, 18 words = 192 bits, 21 words = 224 bits, 24 words = 256 bits
+        const strengthMap = {
+            12: 128,
+            15: 160,
+            18: 192,
+            21: 224,
+            24: 256
+        };
+        const strength = strengthMap[numWords];
+        if (!strength) {
+            throw new Error(`Invalid number of words: ${numWords}. Supported values: 12, 15, 18, 21, 24`);
+        }
+        return bip39__namespace.generateMnemonic(english.wordlist, strength);
     }
     mnemonicToMiniSecret(phrase) {
         services_utilCrypto_configs.validation.mnemonicToMiniSecret(phrase);
-        return utilCrypto.mnemonicToMiniSecret(phrase);
+        // Convert mnemonic to entropy which gives us a 32-byte mini secret for 12-word mnemonics
+        // This matches the behavior of Polkadot's mnemonicToMiniSecret
+        bip39__namespace.mnemonicToEntropy(phrase, english.wordlist);
+        // For 12-word mnemonics, entropy is already 16 bytes (128 bits)
+        // We need to pad it to 32 bytes to match Polkadot's mini secret size
+        // Polkadot uses PBKDF2 with specific parameters, but for compatibility
+        // we can use the seed derivation and take the first 32 bytes
+        const seed = bip39__namespace.mnemonicToSeedSync(phrase);
+        // Return first 32 bytes as Uint8Array to match the expected mini secret format
+        return new Uint8Array(seed.slice(0, 32));
     }
     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
-            }
+        if (value === '') {
+            return false;
+        }
+        const regex = '(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}(==)?|[A-Za-z0-9+\\/]{3}=?)?';
+        if (!(new RegExp('^' + regex + '$', 'gi')).test(value)) {
+            return false;
         }
-        return null;
-    }
-    isAddressValid(address) {
-        services_utilCrypto_configs.validation.isAddressValid(address);
         try {
-            Keyring.encodeAddress(util.isHex(address) ? util.hexToU8a(address) : Keyring.decodeAddress(address));
-            return true;
+            const decoded = Buffer.from(value, 'base64');
+            const asUtf8 = decoded.toString('utf8');
+            const reencoded = Buffer.from(asUtf8, 'utf8').toString('base64');
+            const normalize = (str) => str.replace(/=+$/, '');
+            return normalize(value) === normalize(reencoded);
         }
-        catch (error) {
+        catch (e) {
             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' };
+    hexToString(hex) {
+        try {
+            const bytes = utils.hexToU8a(hex);
+            return utils.u8aToString(bytes);
+        }
+        catch (e) {
+            console.log('error: ', e);
         }
-        return result;
+        return '';
     }
 }
 const utilCryptoService = new UtilCryptoService();