@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/src/services/util-crypto/configs.ts

@@ -3,14 +3,6 @@ import assert from 'assert';
 import {assertAddress} from '../../core/validation';
 
 export const validation = {
-  deriveValidate(uri: string) {
-    assert(!!uri, 'uri is required');
-  },
-
-  isAddressValid(address: string) {
-    assertAddress(address);
-  },
-
   mnemonicGenerate(numWords: number) {
     if (numWords) {
       assert(typeof numWords === 'number', 'invalid number of words');
@@ -20,8 +12,4 @@ export const validation = {
   mnemonicToMiniSecret(phrase: string) {
     assert(typeof phrase === 'string', 'invalid mnemonic phrase');
   },
-
-  mnemonicValidate(phrase: string) {
-    assert(typeof phrase === 'string', 'invalid mnemonic phrase');
-  },
 };

package/src/services/util-crypto/index.test.js

@@ -1,5 +1,4 @@
-import {cryptoWaitReady} from '@polkadot/util-crypto';
-import {assertRpcService, getPromiseError} from '../test-utils';
+import {assertRpcService} from '../test-utils';
 import {validation} from './configs';
 import {utilCryptoService as service} from './service';
 import {UtilCryptoServiceRpc} from './service-rpc';
@@ -10,71 +9,19 @@ describe('UtilCryptoService', () => {
   });
 
   describe('service', () => {
-    beforeAll(async () => {
-      await cryptoWaitReady();
-    });
-
     it('mnemonicGenerate', () => {
       const result = service.mnemonicGenerate(12);
       expect(typeof result).toBe('string');
     });
 
-    it('isAddressValid', async () => {
-      expect(
-        await service.isAddressValid(
-          '3HM9DYxHe5tAwh2cuErNHiLxSMDJhetxaVGCDTYXiwyuuHN6',
-        ),
-      ).toBe(true);
-
-      expect(await service.isAddressValid('wrong value')).toBe(false);
-    });
-
-    describe('mnemonicValidate', () => {
-      it('expect mnemonic to be valid', async () => {
-        const phrase = await service.mnemonicGenerate(12);
-        const isValid = await service.mnemonicValidate(phrase);
-
-        expect(isValid).toBe(true);
-      });
-
-      it('expect mnemonic to be invalid', async () => {
-        const isValid = await service.mnemonicValidate('invalid mnemonic');
-
-        expect(isValid).toBe(false);
-      });
-    });
-
-    describe('deriveValidate', () => {
-      let phrase;
-
-      beforeAll(async () => {
-        phrase = await service.mnemonicGenerate(12);
-      });
-
-      it('expect derive path to be valid', async () => {
-        const result = await service.deriveValidate(`${phrase}/stuff/stuff`);
-        expect(result).toStrictEqual({});
-      });
-
-      it('expect derive path to not be valid', async () => {
-        const error = await getPromiseError(() =>
-          service.deriveValidate('wrong phrase'),
-        );
-        expect(error.message).toBe('invalid derive path');
-      });
-
-      it('expect derive path to have warning', async () => {
-        const result = await service.deriveValidate(
-          `${phrase}/stuff///pass/tst`,
-        );
-
-        expect(result.warning).toBe('slash password detected');
-      });
-    });
-
     describe('isBase64', () => {
       it('expect to be base64', async () => {
         expect(await service.isBase64('dGVzdA==')).toBe(true);
+        expect(
+          await service.isBase64(
+            'eyJ0eXAiOiJhcHBsaWNhdGlvbi9kaWRjb21tLWVuY3J5cHRlZCtqc29uIiwicHJvdGVjdGVkIjoiZXlKbGJtTWlPaUpZUXpJd1VDSjkiLCJyZWNpcGllbnRzIjpbeyJoZWFkZXIiOnsia2lkIjoiZGlkOmtleTp6Nk1raE43UEJqV2dTTVEyNEJlYmRwdnZ3OGZWUnY3bTZNSERxaXdUS296ekJnckojejZMU29qOXpqWmhBcDdNUFFjUndDMnludUJYdXk5YkVnVks1aDNzVFo5c01nMUdtIiwiYWxnIjoiRUNESC0xUFUrQTI1NktXIiwiZXBrIjp7Imt0eSI6Ik9LUCIsImNydiI6IlgyNTUxOSIsIngiOiJoLXE4elVXVkt2VE9GQWNYUVRRbllvckhBQlk0Y044ZVNkRy1yT0JjWlFvIn0sImFwdSI6IlpHbGtPbXRsZVRwNk5rMXJhRTQzVUVKcVYyZFRUVkV5TkVKbFltUndkblozT0daV1VuWTNiVFpOU0VSeGFYZFVTMjk2ZWtKbmNrb2plalpNVTI5cU9YcHFXbWhCY0RkTlVGRmpVbmRETW5sdWRVSllkWGs1WWtWblZrczFhRE56VkZvNWMwMW5NVWR0IiwiYXB2IjoiWkdsa09tdGxlVHA2TmsxcmFFNDNVRUpxVjJkVFRWRXlORUpsWW1Sd2RuWjNPR1pXVW5ZM2JUWk5TRVJ4YVhkVVMyOTZla0puY2tvamVqWk1VMjlxT1hwcVdtaEJjRGROVUZGalVuZERNbmx1ZFVKWWRYazVZa1ZuVmtzMWFETnpWRm81YzAxbk1VZHQiLCJza2lkIjoiZGlkOmtleTp6Nk1raE43UEJqV2dTTVEyNEJlYmRwdnZ3OGZWUnY3bTZNSERxaXdUS296ekJnckojejZMU29qOXpqWmhBcDdNUFFjUndDMnludUJYdXk5YkVnVks1aDNzVFo5c01nMUdtIn0sImVuY3J5cHRlZF9rZXkiOiJNSUxvRFFBWEFFV0xTamdSVnZ3WlduLXE4RUlBUGtCUURpNWEtZDJvX084NW12OERnUncyZHcifV0sIml2IjoiT2FLY21DbW9GTDZiLVRxcVluQ1NUMGFLSkhoUTUwSW4iLCJjaXBoZXJ0ZXh0IjoiTkx4UkkxZjhaNVpQNTVjZVVubHk3SVBKOWpvbXItYUk5RkhlNW9xZHQ5cmNTb3h3RC1CdHItSHdvWmZRZFlPbVRzVndEaVpoQmdmT0ZMeVgtMExlbDl1U3piYjk3SzljQ3h2djBDVnF5a1lNQmpaTno2QWtVek9uS1p0ZWRrWnE3UXFRb2ZNMXoyOEt4SXc5emdSaDNDcWJ0MmpPbTZiMUxfbnkwOWF0TXdob2hZdUpPVko0R2FBdTBBZXJDaURjaDZsNFVGbzU3U2FEdWFvZ3VoTGZ4eUMzZjRFbGVpYUFOcTdmWmhYOEV5ZkxELWpqaEY0RlZocUhXbk5aRTRRbm5JdHhlblRtWi02b0hETDNnaUJCTXFlaXJpcTFFcWpFM1JfVUVqVlJJclEzTmZwSmZqc3V4MnBpY0k5RXp5ZUhMQSIsInRhZyI6IkVDX2NnZzVWSVdfWUNYdno3MzgyUHcifQ',
+          ),
+        ).toBe(true);
       });
 
       it('expect to not be base64', async () => {
@@ -82,29 +29,5 @@ describe('UtilCryptoService', () => {
         expect(await service.isBase64('Test')).toBe(false);
       });
     });
-
-    describe('getAddressPrefix', () => {
-      const MAINNET_PREFIX = 22;
-      const TESTNET_PREFIX = 21;
-      it('expect to match mainnet prefix', () => {
-        const result = service.getAddressPrefix({
-          address: '3EGurYbWGtyVfouDTZjxz1t2jiV3voU9N6sSDAvhHyxaqf8L',
-          startPrefix: TESTNET_PREFIX,
-          endPrefix: MAINNET_PREFIX,
-        });
-
-        expect(result).toBe(MAINNET_PREFIX);
-      });
-
-      it('expect to match testnet prefix', () => {
-        const result = service.getAddressPrefix({
-          address: '37PsGbLmrTfV6VVknkrh6LKACXuC9LuSCwuxhk6ajGDjNCwc',
-          startPrefix: TESTNET_PREFIX,
-          endPrefix: MAINNET_PREFIX,
-        });
-
-        expect(result).toBe(TESTNET_PREFIX);
-      });
-    });
   });
 });

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

@@ -18,26 +18,6 @@ export class UtilCryptoServiceRpc extends RpcService {
     return this.call('mnemonicToMiniSecret', phrase);
   }
 
-  mnemonicValidate(phrase: string): Promise<any> {
-    validation.mnemonicValidate(phrase);
-
-    return this.call('mnemonicValidate', phrase);
-  }
-
-  cryptoWaitReady(): Promise<any> {
-    return this.call('cryptoWaitReady');
-  }
-
-  cryptoIsReady(): Promise<any> {
-    return this.call('cryptoIsReady');
-  }
-
-  isAddressValid(address: string): Promise<any> {
-    validation.deriveValidate(address);
-
-    return this.call('isAddressValid', address);
-  }
-
   deriveValidate(uri: string): Promise<any> {
     validation.deriveValidate(uri);
     return this.call('deriveValidate', uri);

package/src/services/util-crypto/service.ts

@@ -1,44 +1,66 @@
 // @ts-nocheck
-import {decodeAddress, encodeAddress} from '@polkadot/keyring';
-import {hexToU8a, isHex} from '@polkadot/util';
-import {
-  cryptoIsReady,
-  cryptoWaitReady,
-  keyExtractSuri,
-  mnemonicGenerate,
-  mnemonicToMiniSecret,
-  mnemonicValidate,
-} from '@polkadot/util-crypto';
+import {hexToU8a, u8aToString} from '@docknetwork/credential-sdk/utils';
+import * as bip39 from '@scure/bip39';
+import {wordlist} from '@scure/bip39/wordlists/english';
 import assert from 'assert';
 import {validation} from './configs';
 
+function isHex(value: string) {
+  const isDefinitelyHexString = value.startsWith('0x');
+  const isHex =
+    isDefinitelyHexString || (/^[0-9a-fA-F]+$/.test(value) && value.length % 2 === 0);
+
+  return isHex;
+}
+
 export 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) {
     validation.mnemonicGenerate(numWords);
 
-    return 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.generateMnemonic(wordlist, strength);
   }
 
   mnemonicToMiniSecret(phrase) {
     validation.mnemonicToMiniSecret(phrase);
 
-    return 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
+    const entropy = bip39.mnemonicToEntropy(phrase, 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.mnemonicToSeedSync(phrase);
+    
+    // Return first 32 bytes as Uint8Array to match the expected mini secret format
+    return new Uint8Array(seed.slice(0, 32));
   }
 
   isBase64(value) {
@@ -46,72 +68,37 @@ export class UtilCryptoService {
       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
-      }
+    if (value === '') {
+      return false;
     }
 
-    return null;
-  }
-
-  isAddressValid(address) {
-    validation.isAddressValid(address);
+    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;
+    }
 
     try {
-      encodeAddress(
-        isHex(address) ? hexToU8a(address) : decodeAddress(address),
-      );
-
-      return true;
-    } catch (error) {
+      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 (e) {
       return false;
     }
   }
 
-  deriveValidate(uri: string) {
-    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'};
+  hexToString(hex: string): string {
+    try {
+      const bytes = hexToU8a(hex);
+      return u8aToString(bytes);
+    } catch (e) {
+      console.log('error: ', e);
     }
 
-    return result;
+    return '';
   }
 }
 

package/src/services/wallet/configs.ts

@@ -1,59 +1,8 @@
 // @ts-nocheck
 import assert from 'assert';
-import {
-  assertAddress,
-  assertKeyType,
-  assertPassword,
-} from '../../core/validation';
-import {KeypairType} from '../../types';
-
-function assertContent(content: WalletContent) {
-  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}`,
-  );
-}
+import {assertPassword} from '../../core/validation';
 
 export const validation = {
-  getDocumentById(id: string) {
-    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}: ExportAccountParams) {
-    assertAddress(address);
-    assertPassword(password);
-  },
-  create({walletId}: CreateParams): Promise<any> {
-    assert(typeof walletId === 'string', `invalid walletId ${walletId}`);
-  },
-  lock(password: string) {
-    assertPassword(password);
-  },
-  unlock(password: string) {
-    assertPassword(password);
-  },
-  add(params: AddParams) {
-    assertContent(params);
-  },
-  remove(id: string) {
-    assert(typeof id === 'string', 'invalid documentId');
-    assert(!!id, 'documentId is required');
-  },
-  update(params: UpdateParams) {
-    assertContent(params);
-  },
-  query(params: QueryParams) {
-    assert(typeof params === 'object', 'invalid query');
-  },
-  exportWallet(password: string) {
-    assertPassword(password);
-  },
   getDocumentsFromEncryptedWallet({
     encryptedJSONWallet,
     password,
@@ -64,10 +13,6 @@ export const validation = {
     );
     assertPassword(password);
   },
-  importWallet({json, password}: ImportWalletParams) {
-    assert(typeof json === 'object', `invalid json data: ${json}`);
-    assertPassword(password);
-  },
   exportDocuments({documents, password}: ExportDocuments) {
     assert(Array.isArray(documents), 'Invalid Documents');
     assert(documents.length > 0, 'Cannot export empty documents');
@@ -81,50 +26,10 @@ export const validation = {
 
     assertPassword(password);
   },
-  createAccountDocuments(params: CreateAccountDocumentsParams) {
-    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);
-    }
-  },
 };
 
 export const serviceName = 'wallet';
 
-export type WalletContent = {
-  '@context'?: string[],
-  name?: any,
-  id: any,
-  type: DocumentType,
-  value?: any,
-  correlation?: any[],
-};
-
-export type CreateAccountDocumentsParams = {
-  name: string,
-  json?: string,
-  password?: string,
-  mnemonic?: string,
-  type?: KeypairType,
-  derivePath?: string,
-};
-
 export type GetDocumentsFromEncryptedWallet = {
   encryptedJSONWallet: any,
   password: string,
@@ -133,20 +38,3 @@ export type GetDocumentsFromEncryptedWallet = {
 export type ExportDocuments = {
   documents: Array<any>,
 };
-
-export type QueryParams = any;
-export type AddParams = WalletContenxt;
-export type UpdateParams = WalletContent;
-export type RemoveParams = string;
-export type ImportWalletParams = {
-  json: string,
-  password: string,
-};
-export type ExportAccountParams = {
-  address: string,
-  password: string,
-};
-export type CreateParams = {
-  walletId: string,
-  type: string,
-};

package/src/services/wallet/index.test.js

@@ -1,6 +1,3 @@
-import {mnemonicGenerate} from '@polkadot/util-crypto';
-import {NetworkManager} from '../../modules/network-manager';
-import {keyringService} from '../keyring/service';
 import {assertRpcService, getPromiseError} from '../test-utils';
 import {validation} from './configs';
 import {walletService as service, walletService} from './service';
@@ -11,163 +8,7 @@ describe('WalletService', () => {
     assertRpcService(WalletServiceRpc, service, validation);
   });
 
-  let accountDocuments;
-  let testAccount;
-
   describe('service', () => {
-    beforeAll(async () => {
-      await keyringService.initialize({
-        ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-      });
-      await service.create({
-        walletId: 'test',
-        type: 'memory',
-      });
-      await service.load();
-      await service.sync();
-      accountDocuments = await service.createAccountDocuments({
-        mnemonic: mnemonicGenerate(12),
-        name: 'test',
-        type: 'sr25519',
-      });
-
-      testAccount = accountDocuments[0];
-    });
-
-    describe('getDocumentById', () => {
-      it('expect to sum numbers', async () => {
-        const result = await service.getDocumentById(testAccount.id);
-        expect(result.id).toBe(testAccount.id);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getDocumentById(null),
-        );
-
-        expect(error.message).toBe('invalid documentId');
-      });
-    });
-
-    describe('getAccountKeypair', () => {
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getDocumentById(null),
-        );
-
-        expect(error.message).toBe('invalid documentId');
-      });
-    });
-
-    describe('createAccountDocuments', () => {
-      const params = {
-        derivationPath: '',
-        mnemonic: mnemonicGenerate(12),
-        type: 'sr25519',
-        name: 'Test account',
-      };
-      let documents;
-      let correlation;
-
-      beforeAll(async () => {
-        documents = await service.createAccountDocuments(params);
-        correlation = await service.resolveCorrelations(documents[0].id);
-      });
-
-      it('expect to create 4 documents', () => {
-        expect(documents.length).toBe(4);
-      });
-
-      it('expect to create address document ', () => {
-        const document = correlation.find(doc => doc.type === 'Address');
-        expect(document.value).toBe(documents[0].id);
-      });
-
-      it('expect to create mnemonic document', () => {
-        const document = correlation.find(doc => doc.type === 'Mnemonic');
-        expect(document.value).toBe(params.mnemonic);
-      });
-
-      it('expect to create keyringPair document', () => {
-        const document = correlation.find(doc => doc.type === 'KeyringPair');
-        const keyringPairJson = document.value;
-        const keyringPair = keyringService.decryptKeyPair({
-          jsonData: keyringPairJson,
-          password: '',
-        });
-
-        expect(keyringPair.address).toBe(documents[0].value);
-        expect(keyringPair.type).toBe(params.type);
-      });
-
-      it('expect to create DOCK currency document', () => {
-        const document = correlation.find(doc => doc.type === 'Currency');
-        expect(document.value).toBe(0);
-        expect(document.symbol).toBe('DOCK');
-      });
-    });
-
-    describe('exportAccount', () => {
-      it('expect to export account', async () => {
-        const result = await service.exportAccount({
-          address: testAccount.id,
-          password: '123',
-        });
-        expect(result.address).toBe(testAccount.id);
-        const pair = keyringService.addFromJson({
-          jsonData: result,
-          password: '123',
-        });
-        expect(pair.address).toBe(testAccount.id);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.exportAccount({
-            address: undefined,
-            password: null,
-          }),
-        );
-        expect(error.message).toBe('invalid address: undefined');
-      });
-    });
-
-    describe('exportWallet', () => {
-      it('expect to export account', async () => {
-        const result = await service.exportWallet('123');
-        expect(result.id).toBeDefined();
-        expect(result['@context']).toBeDefined();
-        expect(result.type).toBeDefined();
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.exportWallet(undefined),
-        );
-        expect(error.message).toBe('invalid password: undefined');
-      });
-    });
-
-    describe('importWallet', () => {
-      it('expect to export account', async () => {
-        const json = await service.exportWallet('123');
-        await walletService.removeAll();
-        await service.importWallet({json, password: '123'});
-        for (let doc of accountDocuments) {
-          const walletDoc = await walletService.getDocumentById(doc.id);
-          delete walletDoc.hasBackup;
-          delete doc.hasBackup;
-          expect(walletDoc).toStrictEqual(doc);
-        }
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.importWallet({json: undefined}),
-        );
-        expect(error.message).toBe('invalid json data: undefined');
-      });
-    });
     describe('getDocumentsFromEncryptedWallet', () => {
       it('expect to validate params', async () => {
         const error = await getPromiseError(() =>