@docknetwork/wallet-sdk-wasm 1.5.9 → 1.5.11

package/src/services/dids/keypair-utils.js

@@ -0,0 +1,111 @@
+/**
+ * This code is based on the implementation from truvera api
+ * https://github.com/docknetwork/web/blob/3c706c5dc5de4ae63f548c76ec6edeb17533a0c9/apps/api/src/utils/key-manager.js
+ */
+import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
+import {hexToU8a, u8aToHex, u8aToU8a} from '@docknetwork/credential-sdk/utils';
+// import {encodeBase58} from './dock-shared';
+import * as bs58 from 'base58-universal';
+
+export function getKeyPairType(key) {
+  const keyType = key.type || key.constructor.VerKeyType;
+  if (keyType) {
+    return keyType;
+  }
+
+  if (key instanceof Ed25519Keypair) {
+    return 'Ed25519VerificationKey2018';
+  }
+
+  throw new Error(`Unknown key type for ${key.constructor.name}`);
+}
+
+export const MULTIBASE_BASE58BTC_HEADER = 'z';
+export const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
+export const MULTICODEC_ED25519_PRIV_HEADER = new Uint8Array([0x80, 0x26]);
+
+export function encodeMbKey(header, key) {
+  const mbKey = new Uint8Array(header.length + key.length);
+  mbKey.set(header);
+  mbKey.set(key, header.length);
+  return MULTIBASE_BASE58BTC_HEADER + bs58.encode(mbKey);
+}
+
+function getKeyFingerprint(keyType, publicKey) {
+  if (keyType.startsWith('Ed25519')) {
+    return encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, publicKey);
+  } else {
+    throw new Error(`Cannot detect key type for fingerprint: ${keyType}`);
+  }
+}
+
+const keyTypeToDocType = {
+  bjj: 'BJJVerificationKey2021',
+  secp256k1: 'EcdsaSecp256k1VerificationKey2019',
+};
+
+export function keypairToKeydoc(key, controller, id = undefined) {
+  const keyType = getKeyPairType(key);
+  let keyDoc;
+  if (
+    keyType === 'Ed25519VerificationKey2020' ||
+    keyType === 'Ed25519VerificationKey2018'
+  ) {
+    const publicKey = u8aToU8a(
+      (key.keyPair &&
+        key.keyPair.publicKey &&
+        u8aToU8a(key.keyPair.publicKey)) ||
+        key.publicKeyBuffer ||
+        (key.pk && key.pk.value),
+    );
+
+    if (!publicKey) {
+      throw new Error('Cannot find public key');
+    }
+
+    const pk = u8aToU8a(
+      (key.keyPair && key.keyPair.secretKey) ||
+        key.privateKeyBuffer ||
+        (key.sk &&
+          (typeof key.sk === 'string'
+            ? hexToU8a(key.sk)
+            : key.sk.value || key.sk)) ||
+        hexToU8a(key.pk),
+    );
+
+    const publicKeyBase58 = bs58.encode(publicKey);
+    const privateKeyBase58 = bs58.encode(pk);
+
+    const fingerprint =
+      (key.fingerprint && key.fingerprint()) ||
+      getKeyFingerprint(keyType, publicKey);
+
+    // auto create controller
+    if (!controller) {
+      controller = `did:key:${fingerprint}`;
+      id = id || key.id || `${controller}#${fingerprint}`;
+    }
+
+    const keyId = id || key.id || `${controller}#${fingerprint}`;
+    const type = keyTypeToDocType[keyType] || keyType;
+    keyDoc = {
+      controller,
+      type,
+      id: keyId,
+      publicKeyMultibase: encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, publicKey),
+      privateKeyMultibase: encodeMbKey(MULTICODEC_ED25519_PRIV_HEADER, pk),
+      privateKeyBase58,
+      publicKeyBase58,
+    };
+
+    if (key.seed) {
+      keyDoc.seed = u8aToHex(key.seed);
+    }
+  } else {
+    throw new Error(`Unknown keypairToKeydoc type: ${keyType}`);
+  }
+
+  keyDoc['@context'] = ['https://w3id.org/wallet/v1'];
+
+  return keyDoc;
+}

package/src/services/dids/service-rpc.ts

@@ -21,9 +21,6 @@ export class DIDServiceRPC extends RpcService {
   deriveKeyDoc(params) {
     return this.call('deriveKeyDoc', params);
   }
-  getDidDockDocument(did) {
-    return this.call('getDidDockDocument', did);
-  }
   createSignedJWT(params) {
     return this.call('createSignedJWT', params);
   }

package/src/services/dids/service.ts

@@ -6,7 +6,6 @@ import {
   KeypairToDIDKeyDocumentParams,
   GetDIDResolutionParams,
 } from './config';
-import {keyringService} from '../keyring/service';
 import {utilCryptoService} from '../util-crypto/service';
 import assert from 'assert';
 import {blockchainService, getDock} from '../blockchain/service';
@@ -20,17 +19,17 @@ import {
 import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
 import {Logger} from '../../core/logger';
-import {polkadotToKeydoc} from '../../core/polkadot-utils';
 import base64url from 'base64url';
 import {keyDocToKeypair} from '../credential/utils';
 import {
   Ed25519Signature2020,
   EcdsaSecp256k1Signature2019,
 } from '@docknetwork/credential-sdk/vc/crypto';
+import { keypairToKeydoc } from './keypair-utils';
 
 async function getSignerKeypair(privateKeyDoc) {
   const privateKey =
-    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, blockchainService.dock);
+    privateKeyDoc.keypair || await keyDocToKeypair(privateKeyDoc);
 
   if (!privateKey.signer && privateKey.sign) {
     privateKey.signer = () => ({sign: ({data}) => privateKey.sign(data)});
@@ -67,7 +66,6 @@ class DIDService {
     DIDService.prototype.getDIDResolution,
     DIDService.prototype.generateKeyDoc,
     DIDService.prototype.deriveKeyDoc,
-    DIDService.prototype.getDidDockDocument,
     DIDService.prototype.createSignedJWT,
   ];
   keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
@@ -84,34 +82,16 @@ class DIDService {
 
   async generateKeyDoc(params) {
     validation.generateKeyDoc(params);
-    const {derivePath = '', type = 'ed25519', keyPairJSON} = params;
-    let keyring;
-
-    if (keyPairJSON) {
-      keyring = keyringService.keyring.addFromJson(keyPairJSON);
-      keyring.unlock('');
-    } else {
-      const mnemonic = await utilCryptoService.mnemonicGenerate(12);
-      keyring = keyringService.getKeyringPair({
-        mnemonic,
-        derivePath,
-        type,
-      });
-    }
-
-    return polkadotToKeydoc(keyring, params.controller);
+    const {derivePath = '', type = 'ed25519'} = params;
+    const keyPair = Ed25519Keypair.random()
+    return keypairToKeydoc(keyPair, params.controller);
   }
 
   async deriveKeyDoc(params) {
     validation.deriveKeyDoc(params);
     const { pair, type = 'ed25519' } = params;
-
-    const keyring = keyringService.createFromPair({
-      pair,
-      type,
-    });
-
-    return polkadotToKeydoc(keyring, params.controller);
+    const keyPair = new Ed25519Keypair(pair.secretKey, 'private')
+    return keypairToKeydoc(keyPair, params.controller);
   }
 
   async createSignedJWT({payload, privateKeyDoc, headerInput}) {
@@ -133,13 +113,6 @@ class DIDService {
     const signature = await sign({data: signPayload});
     return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
   }
-
-  async getDidDockDocument(did) {
-    assert(!!did, 'DID is required');
-    const dock = blockchainService.dock;
-    const result = await blockchainService.modules.did.getDocument(did);
-    return result;
-  }
 }
 
 export const didService = new DIDService();

package/src/services/edv/service.ts

@@ -8,8 +8,7 @@ import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key
 import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
 import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
 import {didService} from '@docknetwork/wallet-sdk-wasm/src/services/dids/service';
-import {keyringService} from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
-import {ed25519PairFromSeed} from '@polkadot/util-crypto';
+import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
 /**
  * EDVService
@@ -97,9 +96,6 @@ export class EDVService {
   }
 
   async generateKeys() {
-    await keyringService.initialize({
-      ss58Format: 22,
-    });
     const keyPair = await didService.generateKeyDoc({});
 
     const verificationKey = await Ed25519VerificationKey2018.generate({
@@ -116,10 +112,7 @@ export class EDVService {
   }
 
   async deriveKeys(masterKey: Uint8Array) {
-    await keyringService.initialize({
-      ss58Format: 22,
-    });
-    const pair = ed25519PairFromSeed(masterKey);
+    const {keyPair: pair} = new Ed25519Keypair(masterKey, 'seed');
 
     const keyPair = await didService.deriveKeyDoc({ pair });
 

package/src/services/index.js

@@ -1,7 +1,5 @@
-import {keyringService} from './keyring/service';
 import {blockchainService} from './blockchain/service';
 import {walletService} from './wallet/service';
-import {polkadotService} from './polkadot/service';
 import {utilCryptoService} from './util-crypto/service';
 import {storageService} from './storage/service';
 import {didService} from './dids/service';
@@ -11,10 +9,8 @@ import {pexService} from './pex/service';
 import {edvService} from './edv/service';
 
 export default [
-  keyringService,
   blockchainService,
   walletService,
-  polkadotService,
   utilCryptoService,
   storageService,
   didService,

package/src/services/test-utils.js

@@ -1,18 +1,6 @@
-import {cryptoWaitReady} from '@polkadot/util-crypto';
 import assert from 'assert';
-import {TestFixtures} from '../fixtures';
 import {NetworkManager} from '../modules/network-manager';
-import {keyringService} from './keyring';
 import {RpcService} from './rpc-service-client';
-import {walletService} from './wallet';
-
-export async function initializeWalletService() {
-  await cryptoWaitReady();
-  await keyringService.initialize({
-    ss58Format: 21,
-  });
-  await walletService.create('test-wallet', 'memory');
-}
 
 export const TEST_FEE_AMOUNT = 2.48;
 export const API_MOCK_DISABLED = process.env.API_MOCK_DISABLED === 'true';
@@ -39,23 +27,6 @@ export 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;
 }
 

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,36 +18,11 @@ 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);
-  }
-
   isBase64(value: string): Promise<boolean> {
     return this.call('isBase64', value);
   }
 
-  getAddressPrefix(params: any): Promise<number | null> {
-    return this.call('getAddressPrefix', params);
+  hexToString(hex: string): Promise<string> {
+    return this.call('hexToString', hex);
   }
 }

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 '';
   }
 }