@docknetwork/wallet-sdk-wasm 0.4.19

package/src/services/keyring/configs.ts

@@ -0,0 +1,89 @@
+// @ts-nocheck
+import assert from 'assert';
+import {assertKeyType} from '../../core/validation';
+
+export const validation = {
+  addFromJson({jsonData, password}: AddFromJsonParams) {
+    assert(typeof jsonData === 'object', 'invalid jsonData');
+    assert(typeof password === 'string', 'invalid password');
+  },
+  initialize({ss58Format, type}: InitializeParams) {
+    assert(typeof ss58Format === 'number', 'invalid ss58Format');
+
+    if (type) {
+      assertKeyType(type);
+    }
+  },
+  addFromMnemonic({mnemonic, meta, type}: AddFromMnemonicParams) {
+    assert(typeof mnemonic === 'string', 'invalid mnemonic');
+
+    if (type) {
+      assertKeyType(type);
+    }
+
+    if (meta) {
+      assert(typeof meta === 'object', 'invalid meta');
+    }
+  },
+  getKeyringPair(params: GetKeyringParams) {
+    const {mnemonic, derivePath, meta, type} = params;
+
+    assert(
+      !params.keyPairType,
+      'invalid parameter keyPairType, you should use type instead',
+    );
+
+    assert(typeof mnemonic === 'string', 'invalid mnemonic');
+
+    if (derivePath) {
+      assert(typeof derivePath === 'string', 'invalid derivePath');
+    }
+
+    if (type) {
+      assertKeyType(type);
+    }
+
+    if (meta) {
+      assert(typeof meta === 'object', 'invalid meta');
+    }
+  },
+
+  signData(params: SignDataParams) {
+    assert(!!params.keyPair, 'invalid keypair');
+    assert(!!params.data, 'invalid data');
+  },
+};
+
+validation.addressFromUri = validation.getKeyringPair;
+
+export const serviceName = 'keyring';
+
+export type GetKeyringParams = {
+  mnemonic: string,
+  meta?: any,
+  type?: string,
+  derivePath?: string,
+};
+
+export type AddressFromUriParams = GetKeyringParams;
+
+export type AddFromJsonParams = {
+  jsonData: string,
+  password: string,
+};
+
+export type InitializeParams = {
+  ss58Format: number,
+  type?: string,
+};
+
+export type AddFromMnemonicParams = {
+  mnemonic: string,
+  meta?: any,
+  type: string,
+};
+
+export type SignDataParams = {
+  keyPair: any,
+  data: any,
+};

package/src/services/keyring/index.android.js

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

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

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

package/src/services/keyring/index.js

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

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

@@ -0,0 +1,48 @@
+import {mnemonicGenerate} from '@polkadot/util-crypto';
+import {NetworkManager} from '../../modules/network-manager';
+import {assertRpcService, getPromiseError} from '../test-utils';
+import {validation} from './configs';
+import {keyringService as service} from './service';
+import {KeyringServiceRpc} from './service-rpc';
+
+describe('KeyringService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(KeyringServiceRpc, service, validation);
+  });
+
+  describe('service', () => {
+    beforeAll(async () => {});
+
+    describe('initialize', () => {
+      it('expect to initialize keyring', async () => {
+        await service.initialize({
+          ss58Format:
+            NetworkManager.getInstance().getNetworkInfo().addressPrefix,
+        });
+
+        expect(service.keyring).toBeDefined();
+      });
+
+      it('expect to validate params', async () => {
+        const error = await getPromiseError(() => service.initialize({}));
+        expect(error.message).toBe('invalid ss58Format');
+      });
+    });
+
+    describe('addFromMnemonic', () => {
+      it('expect to add keypair from mnemonic', async () => {
+        await service.addFromMnemonic({
+          mnemonic: mnemonicGenerate(12),
+        });
+
+        expect(service.keyring).toBeDefined();
+      });
+
+      it('expect to validate params', async () => {
+        const error = await getPromiseError(() => service.addFromMnemonic({}));
+
+        expect(error.message).toBe('invalid mnemonic');
+      });
+    });
+  });
+});

package/src/services/keyring/service-rpc.js

@@ -0,0 +1,56 @@
+import {RpcService} from '../rpc-service-client';
+import {
+  AddFromJsonParams,
+  AddFromMnemonicParams,
+  AddressFromUriParams,
+  GetKeyringParams,
+  serviceName,
+  validation,
+  SignDataParams,
+} from './configs';
+
+export class KeyringServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  initialize(params: InitializeParams) {
+    validation.initialize(params);
+    return this.call('initialize', params);
+  }
+
+  addFromMnemonic(params: AddFromMnemonicParams) {
+    validation.addFromMnemonic(params);
+    return this.call('addFromMnemonic', params);
+  }
+
+  addFromJson(params: AddFromJsonParams) {
+    validation.addFromJson(params);
+    return this.call('addFromJson', params);
+  }
+
+  decryptKeyPair(params: AddFromJsonParams) {
+    validation.addFromJson(params);
+    return this.call('decryptKeyPair', params);
+  }
+
+  getKeyringPair(params: GetKeyringParams) {
+    validation.getKeyringPair(params);
+    return this.call('getKeyringPair', params);
+  }
+
+  getKeyringPairJSON(params: GetKeyringParams) {
+    validation.getKeyringPair(params);
+    return this.call('getKeyringPairJSON', params);
+  }
+
+  addressFromUri(params: AddressFromUriParams) {
+    validation.addressFromUri(params);
+    return this.call('addressFromUri', params);
+  }
+
+  signData(params: SignDataParams) {
+    validation.signData(params);
+    return this.call('signData', params);
+  }
+}

package/src/services/keyring/service.ts

@@ -0,0 +1,98 @@
+// @ts-nocheck
+import Keyring from '@polkadot/keyring';
+import {cryptoWaitReady} from '@polkadot/util-crypto';
+import {
+  AddFromJsonParams,
+  AddFromMnemonicParams,
+  CreateFromUriParams,
+  InitializeParams,
+  serviceName,
+  validation,
+  SignDataParams,
+} from './configs';
+
+export function getKeyring() {
+  return keyringService.keyring;
+}
+
+export class KeyringService {
+  keyring: Keyring;
+
+  rpcMethods = [
+    KeyringService.prototype.addFromJson,
+    KeyringService.prototype.addFromMnemonic,
+    KeyringService.prototype.addressFromUri,
+    KeyringService.prototype.getKeyringPair,
+    KeyringService.prototype.getKeyringPairJSON,
+    KeyringService.prototype.initialize,
+    KeyringService.prototype.signData,
+    KeyringService.prototype.decryptKeyPair,
+  ];
+
+  constructor() {
+    this.name = serviceName;
+  }
+
+  async initialize(params: InitializeParams) {
+    await cryptoWaitReady();
+
+    validation.initialize(params);
+
+    this.keyring = new Keyring(params);
+
+    return true;
+  }
+
+  addFromMnemonic({mnemonic, meta, type}: AddFromMnemonicParams) {
+    validation.addFromMnemonic({mnemonic, meta, type});
+    return this.keyring.addFromMnemonic(mnemonic, meta, type);
+  }
+
+  decryptKeyPair({jsonData, password}: {keyPair: any, password: string}) {
+    validation.addFromJson({jsonData, password});
+
+    const pair = this.keyring.addFromJson(jsonData);
+
+    pair.unlock(password);
+
+    return pair;
+  }
+
+  addFromJson({jsonData, password}: AddFromJsonParams) {
+    validation.addFromJson({jsonData, password});
+
+    const pair = this.keyring.addFromJson(jsonData);
+
+    pair.unlock(password);
+
+    return pair.toJson();
+  }
+
+  signData(params: SignDataParams): any {
+    validation.signData(params);
+    const account = this.keyring.addFromPair(params.keyPair);
+    return account.sign(params.data);
+  }
+
+  getKeyringPair(params: CreateFromUriParams): KeyringPair {
+    validation.getKeyringPair(params);
+
+    const {mnemonic, meta, type, derivePath = ''} = params;
+
+    return this.keyring.createFromUri(
+      `${mnemonic.trim()}${derivePath}`,
+      meta,
+      type,
+    );
+  }
+
+  getKeyringPairJSON(params: CreateFromUriParams): KeyringPair {
+    return this.getKeyringPair(params).toJson();
+  }
+
+  addressFromUri(params: CreateFromUriParams) {
+    return this.getKeyringPair(params).address;
+  }
+}
+
+export const keyringService: KeyringService = new KeyringService();

package/src/services/pex/config.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import assert from 'assert';
+
+export const serviceName = 'pex';
+export const validation = {
+  filterCredentials: (params: FilterCredentialsParams) => {
+    assert(params.credentials, 'credentials is required');
+    assert(params.presentationDefinition, 'presentationDefinition is required');
+  },
+  evaluatePresentation: (params: EvaluatePresentationParams) => {
+    assert(params.presentation, 'presentation is required');
+    assert(params.presentationDefinition, 'presentationDefinition is required');
+  },
+};
+
+export type FilterCredentialsParams = {
+  credentials: any[];
+  presentationDefinition: any;
+  holderDIDs: string[];
+};
+
+export type EvaluatePresentationParams = {
+  presentation: any;
+  presentationDefinition: any;
+};

package/src/services/pex/index.android.js

@@ -0,0 +1,2 @@
+import {PEXServiceRPC} from './service-rpc';
+export const pexService = new PEXServiceRPC();

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

@@ -0,0 +1,2 @@
+import {PEXServiceRPC} from './service-rpc';
+export const pexService = new PEXServiceRPC();

package/src/services/pex/index.js

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

package/src/services/pex/service-rpc.js

@@ -0,0 +1,22 @@
+import {RpcService} from '../rpc-service-client';
+import {
+  serviceName,
+  FilterCredentialsParams,
+  validation,
+  EvaluatePresentationParams,
+} from './config';
+
+export class PEXServiceRPC extends RpcService {
+  constructor() {
+    super(serviceName);
+    this.sandbox = process.env.NODE_ENV !== 'test';
+  }
+  async filterCredentials(params: FilterCredentialsParams) {
+    validation.filterCredentials(params);
+    return this.call('filterCredentials', params);
+  }
+  async evaluatePresentation(params: EvaluatePresentationParams) {
+    validation.evaluatePresentation(params);
+    return this.call('evaluatePresentation', params);
+  }
+}

package/src/services/pex/service.ts

@@ -0,0 +1,68 @@
+// @ts-nocheck
+import {
+  serviceName,
+  validation,
+  EvaluatePresentationParams,
+  FilterCredentialsParams,
+} from './config';
+import {PEX} from '@sphereon/pex';
+
+const pex: PEX = new PEX();
+
+/**
+ * @sphereon/pex is not able to handle optional attributes in the presentation definition
+ * https://github.com/Sphereon-Opensource/PEX/issues/150
+ * Any optional attribute in the presentation definition will cause the library to throw an error
+ * This function removes the optional attribute from the presentation definition
+ * This is a temporary workaround until the issue is fixed in the @sphereon/pex library
+ **/
+export function removeOptionalAttribute(presentationDefinition) {
+  presentationDefinition.input_descriptors.forEach(inputDescriptor => {
+    if (inputDescriptor.constraints && inputDescriptor.constraints.fields) {
+      inputDescriptor.constraints.fields =
+        inputDescriptor.constraints.fields.filter(
+          field => field.optional === undefined,
+        );
+    }
+  });
+
+  return presentationDefinition;
+}
+
+class PEXService {
+  name: string;
+
+  constructor() {
+    this.name = serviceName;
+  }
+
+  rpcMethods = [
+    PEXService.prototype.filterCredentials,
+    PEXService.prototype.evaluatePresentation,
+  ];
+
+  filterCredentials(params: FilterCredentialsParams) {
+    validation.filterCredentials(params);
+    const {credentials, presentationDefinition, holderDIDs} = params;
+    const result = pex.selectFrom(
+      removeOptionalAttribute(presentationDefinition),
+      credentials,
+      holderDIDs,
+    );
+
+    return result;
+  }
+
+  evaluatePresentation(params: EvaluatePresentationParams) {
+    validation.evaluatePresentation(params);
+    const {presentation, presentationDefinition} = params;
+    const result = pex.evaluatePresentation(
+      removeOptionalAttribute(presentationDefinition),
+      presentation,
+    );
+
+    return result;
+  }
+}
+
+export const pexService = new PEXService();

package/src/services/pex/tests/jest.config.js

@@ -0,0 +1,21 @@
+module.exports = {
+  testEnvironment: 'node',
+  testTimeout: 30000,
+  coverageThreshold: {
+    global: {
+      branches: 10,
+      functions: 10,
+      lines: 10,
+      statements: 10,
+    },
+  },
+  transform: {
+    '^.+\\.(js|jsx)$': [
+      'babel-jest',
+      {
+        configFile: require.resolve('../../../../babel.config.js'),
+      },
+    ],
+  },
+  resetMocks: false,
+};