@docknetwork/wallet-sdk-wasm 0.4.19

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

@@ -0,0 +1,110 @@
+import {cryptoWaitReady} from '@polkadot/util-crypto';
+import {assertRpcService, getPromiseError} from '../test-utils';
+import {validation} from './configs';
+import {utilCryptoService as service} from './service';
+import {UtilCryptoServiceRpc} from './service-rpc';
+
+describe('UtilCryptoService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(UtilCryptoServiceRpc, service, validation);
+  });
+
+  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);
+      });
+
+      it('expect to not be base64', async () => {
+        expect(await service.isBase64('wrong value')).toBe(false);
+        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

@@ -0,0 +1,47 @@
+import {RpcService} from '../rpc-service-client';
+import {validation} from './configs';
+
+export class UtilCryptoServiceRpc extends RpcService {
+  constructor() {
+    super('utilCrypto');
+  }
+
+  mnemonicGenerate(numWords: number): Promise<any> {
+    validation.mnemonicGenerate(numWords);
+
+    return this.call('mnemonicGenerate', numWords);
+  }
+
+  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);
+  }
+}

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

@@ -0,0 +1,110 @@
+// @ts-nocheck
+import {decodeAddress, encodeAddress} from '@polkadot/keyring';
+import {hexToU8a, isHex} from '@polkadot/util';
+import {
+  cryptoIsReady,
+  cryptoWaitReady,
+  keyExtractSuri,
+  mnemonicGenerate,
+  mnemonicValidate,
+} from '@polkadot/util-crypto';
+import assert from 'assert';
+import {validation} from './configs';
+
+export 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: 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'};
+    }
+
+    return result;
+  }
+}
+
+export const utilCryptoService: UtilCryptoService = new UtilCryptoService();

package/src/services/wallet/configs.ts

@@ -0,0 +1,152 @@
+// @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}`,
+  );
+}
+
+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,
+  }: GetDocumentsFromEncryptedWallet) {
+    assert(
+      typeof encryptedJSONWallet === 'object',
+      `invalid json data: ${encryptedJSONWallet}`,
+    );
+    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');
+    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: 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,
+};
+
+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.android.js

@@ -0,0 +1,3 @@
+import {WalletServiceRpc} from './service-rpc';
+
+export const walletService = new WalletServiceRpc();

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

@@ -0,0 +1,3 @@
+import {WalletServiceRpc} from './service-rpc';
+
+export const walletService = new WalletServiceRpc();

package/src/services/wallet/index.js

@@ -0,0 +1 @@
+export {walletService} from './service';