@docknetwork/wallet-sdk-wasm 0.4.22 → 1.5.0

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

@@ -1,11 +1,10 @@
-import {assertRpcService, getPromiseError} from '../test-utils';
+import {assertRpcService} from '../test-utils';
 import {DIDServiceRPC} from './service-rpc';
 import {didService as service} from './service';
 import {validation} from './config';
 import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
-import {TestFixtures} from '../../fixtures';
 import {getTestWallet} from '../../test/setup-test-state';
-import {getDock} from '../dock/service';
+import {blockchainService} from '../blockchain/service';
 
 describe('DID Service', () => {
   beforeAll(async () => {
@@ -98,28 +97,11 @@ describe('DID Service', () => {
     spy.mockReset();
   });
 
-  it('expect to register did dock', async () => {
-    const result = await service.registerDidDock(
-      TestFixtures.account1.getKeyring().toJson(''),
-    );
-    expect(result.dockDID).toBeDefined();
-    expect(result.keyPairWalletId).toBeDefined();
-  });
-
-  it('expect to fail to register did dock', async () => {
-    const error = await getPromiseError(() =>
-      service.registerDidDock(
-        TestFixtures.noBalanceAccount.getKeyring().toJson(''),
-      ),
-    );
-    expect(error.message).toBe(
-      '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low',
-    );
-  });
-
   it('expect to get did document', async () => {
     const document = 'document';
-    jest.spyOn(getDock().did, 'getDocument').mockResolvedValue(document);
+    jest
+      .spyOn(blockchainService.didModule, 'getDocument')
+      .mockResolvedValue(document);
 
     const result = await service.getDidDockDocument(
       'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',

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

@@ -18,8 +18,8 @@ export class DIDServiceRPC extends RpcService {
   generateKeyDoc(params) {
     return this.call('generateKeyDoc', params);
   }
-  registerDidDock(keyPair) {
-    return this.call('registerDidDock', keyPair);
+  deriveKeyDoc(params) {
+    return this.call('deriveKeyDoc', params);
   }
   getDidDockDocument(did) {
     return this.call('getDidDockDocument', did);

package/src/services/dids/service.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
 import {
   serviceName,
@@ -8,20 +9,28 @@ import {
 import {keyringService} from '../keyring/service';
 import {utilCryptoService} from '../util-crypto/service';
 import assert from 'assert';
-import {createNewDockDID} from '@docknetwork/sdk/utils/did';
-import {dockService, getDock} from '../dock/service';
-import {PublicKeySr25519} from '@docknetwork/sdk';
-import {DidKey, VerificationRelationship} from '@docknetwork/sdk/public-keys';
+import {blockchainService, getDock} from '../blockchain/service';
+
+import {
+  DidKey,
+  DockDid,
+  VerificationRelationship,
+  DidMethodKey,
+} from '@docknetwork/credential-sdk/types';
+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 from '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
-import EcdsaSecp256k1Signature2019 from '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
+import {keyDocToKeypair} from '../credential/utils';
+import {
+  Ed25519Signature2020,
+  EcdsaSecp256k1Signature2019,
+} from '@docknetwork/credential-sdk/vc/crypto';
 
 async function getSignerKeypair(privateKeyDoc) {
   const privateKey =
-    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, dockService.dock);
+    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, blockchainService.dock);
 
   if (!privateKey.signer && privateKey.sign) {
     privateKey.signer = () => ({sign: ({data}) => privateKey.sign(data)});
@@ -57,10 +66,9 @@ class DIDService {
     DIDService.prototype.keypairToDIDKeyDocument,
     DIDService.prototype.getDIDResolution,
     DIDService.prototype.generateKeyDoc,
-    DIDService.prototype.registerDidDock,
+    DIDService.prototype.deriveKeyDoc,
     DIDService.prototype.getDidDockDocument,
     DIDService.prototype.createSignedJWT,
-
   ];
   keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
     validation.keypairToDIDKeyDocument(params);
@@ -94,11 +102,19 @@ class DIDService {
     return polkadotToKeydoc(keyring, params.controller);
   }
 
-  async createSignedJWT({
-    payload,
-    privateKeyDoc,
-    headerInput
-  }) {
+  async deriveKeyDoc(params) {
+    validation.deriveKeyDoc(params);
+    const { pair, type = 'ed25519' } = params;
+
+    const keyring = keyringService.createFromPair({
+      pair,
+      type,
+    });
+
+    return polkadotToKeydoc(keyring, params.controller);
+  }
+
+  async createSignedJWT({payload, privateKeyDoc, headerInput}) {
     const privateKey = await getSignerKeypair(privateKeyDoc);
     const {sign} =
       typeof privateKey.signer === 'function'
@@ -113,43 +129,17 @@ class DIDService {
     const payloadBase64URL = base64url(JSON.stringify(payload));
     const headerAndPayloadBase64URL = `${headerBase64URL}.${payloadBase64URL}`;
     const signPayload = Buffer.from(headerAndPayloadBase64URL);
-  
+
     const signature = await sign({data: signPayload});
     return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
   }
 
   async getDidDockDocument(did) {
     assert(!!did, 'DID is required');
-    const dock = getDock();
-    const result = await dock.did.getDocument(did);
+    const dock = blockchainService.dock;
+    const result = await blockchainService.didModule.getDocument(did);
     return result;
   }
-
-  async registerDidDock(keyPairJSON) {
-    assert(!!keyPairJSON, 'keyPair is required');
-    const dockDID = createNewDockDID();
-    const dock = getDock();
-    const keyPair = keyringService.keyring.addFromJson(keyPairJSON);
-
-    keyPair.unlock('');
-
-    dock.setAccount(keyPair);
-
-    const publicKey = PublicKeySr25519.fromKeyringPair(keyPair);
-
-    const didKey = new DidKey(publicKey, new VerificationRelationship());
-
-    Logger.info(`Submitting new DID: ${dockDID}`);
-
-    const result = await dock.did.new(dockDID, [didKey], [], false);
-
-    Logger.info(`DID created with tx hash ${result.txHash.toString()}`);
-
-    return {
-      dockDID,
-      keyPairWalletId: keyPairJSON.address,
-    };
-  }
 }
 
 export const didService = new DIDService();

package/src/services/edv/hmac.ts

@@ -1,5 +1,6 @@
 import * as base64url from 'base64url-universal';
 import crypto from '@docknetwork/universal-wallet/crypto';
+import {hexToU8a} from '@polkadot/util';
 
 export default class HMAC {
   key: CryptoKey;
@@ -37,6 +38,18 @@ export default class HMAC {
     return key;
   }
 
+  static async deriveKey(baseKey: string) {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      hexToU8a(baseKey),
+      {name: 'HMAC', hash: {name: 'SHA-256'}},
+      true,
+      ['sign', 'verify'],
+    );
+
+    return key;
+  }
+
   static async exportKey(key: CryptoKey) {
     const rawKey = await crypto.subtle.exportKey('raw', key);
     return base64url.encode(Buffer.from(rawKey));

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

@@ -20,5 +20,27 @@ describe('EDVService', () => {
         expect(keys.verificationKey).toBeDefined();
       });
     });
+
+    describe('deriveKeys', () => {
+      it('should derive EDV keys', async () => {
+        const testMasterKey = '0O+9vxwb3Zo/9AVcQfVeQ59wvgcYUVH/mTye6islspM=';
+        const derivedTestAgreementKey =
+          '{"id":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru#z6LSojEubzYtAGCBE7Mwwks7J3Gttsrd1c9EXcDuNjthwVQj","controller":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","type":"X25519KeyAgreementKey2020","publicKeyMultibase":"z6LSojEubzYtAGCBE7Mwwks7J3Gttsrd1c9EXcDuNjthwVQj","privateKeyMultibase":"z3weoV5H5DppQ7pjABoopaiDFN6zH3SokESte2Jte87YNXgg"}';
+        const derivedTestHmacKey = 'AAkACzAAmgwPDgWQAMAAAAAOYAAAAA';
+        const derivedTestVerificationKey =
+          '{"id":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru#z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","controller":"did:key:z6Mkt1paLGw6VqRCTmqjpbiP9fxLVHJb8k97zERL6TcWr9Ru","type":"Ed25519VerificationKey2018","publicKeyBase58":"EZZXk2gfAHvjMH1392kYJaQLfi2jirtmJDWQGBeVvveX","privateKeyBase58":"5BHUEjDDbDzQKnveM9qXXXmRqwTtmBvumTY2xZXN61x8dvZHgzsDaTpkVqkE4LSoMLcV6yDRhxcv7mMTzdaJ21pX"}';
+        const {agreementKey, hmacKey, verificationKey} =
+          await service.deriveKeys(testMasterKey);
+
+        expect(hmacKey).toBeDefined();
+        expect(hmacKey).toBe(derivedTestHmacKey);
+        expect(verificationKey).toBeDefined();
+        expect(JSON.stringify(verificationKey)).toBe(
+          derivedTestVerificationKey,
+        );
+        expect(agreementKey).toBeDefined();
+        expect(JSON.stringify(agreementKey)).toBe(derivedTestAgreementKey);
+      });
+    });
   });
 });

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

@@ -15,6 +15,10 @@ export class EDVServiceRpc extends RpcService {
     return this.call('generateKeys');
   }
 
+  deriveKeys() {
+    return this.call('deriveKeys');
+  }
+
   find(params: any) {
     return this.call('find', params);
   }

package/src/services/edv/service.ts

@@ -3,11 +3,14 @@ import {InitializeEDVParams, serviceName} from './configs';
 import EDVHTTPStorageInterface from '@docknetwork/universal-wallet/storage/edv-http-storage';
 import HMAC from './hmac';
 import {Ed25519VerificationKey2018} from '@digitalbazaar/ed25519-verification-key-2018';
+import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-key-2020';
 import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key-2020';
 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 base64url from 'base64url-universal';
 
 /**
  * EDVService
@@ -19,6 +22,7 @@ export class EDVService {
 
   rpcMethods = [
     EDVService.prototype.generateKeys,
+    EDVService.prototype.deriveKeys,
     EDVService.prototype.initialize,
     EDVService.prototype.find,
     EDVService.prototype.update,
@@ -109,6 +113,24 @@ export class EDVService {
     return {verificationKey, agreementKey, hmacKey};
   }
 
+  async deriveKeys(masterKey: any) {
+    await keyringService.initialize({
+      ss58Format: 22,
+    });
+    const pair = ed25519PairFromSeed(base64url.decode(masterKey));
+
+    const keyPair = await didService.deriveKeyDoc({ pair });
+
+    const verificationKey = await Ed25519VerificationKey2018.from(keyPair);
+
+    const verificationKey2020 = await Ed25519VerificationKey2020.fromEd25519VerificationKey2018({ keyPair });
+    const agreementKey = await X25519KeyAgreementKey2020.fromEd25519VerificationKey2020({ keyPair: verificationKey2020 });
+
+    const hmacKey = await HMAC.exportKey(await HMAC.deriveKey(masterKey));
+
+    return { verificationKey, agreementKey, hmacKey };
+  }
+
   find(params: any) {
     return this.storageInterface.find(params);
   }

package/src/services/example/service.ts

@@ -4,7 +4,9 @@ import {SumParams, validation} from './configs';
 export class ExampleService {
   rpcMethods = [ExampleService.prototype.sum];
 
-  constructor() {}
+  constructor() {
+    this.name = 'example';
+  }
 
   sum(params: SumParams) {
     validation.sum(params);

package/src/services/index.js

@@ -1,5 +1,5 @@
 import {keyringService} from './keyring/service';
-import {dockService} from './dock/service';
+import {blockchainService} from './blockchain/service';
 import {substrateService} from './substrate/service';
 import {walletService} from './wallet/service';
 import {polkadotService} from './polkadot/service';
@@ -14,7 +14,7 @@ import {edvService} from './edv/service';
 
 export default [
   keyringService,
-  dockService,
+  blockchainService,
   substrateService,
   walletService,
   polkadotService,

package/src/services/keyring/configs.ts

@@ -47,6 +47,21 @@ export const validation = {
       assert(typeof meta === 'object', 'invalid meta');
     }
   },
+  createFromPair(params: CreateFromPairParams) {
+    const {pair, meta, type} = params;
+
+    assert(typeof pair === 'object', 'invalid pair');
+    assert(pair.publicKey instanceof Uint8Array, 'invalid publicKey');
+    assert(pair.secretKey instanceof Uint8Array, 'invalid secretKey');
+
+    if (type) {
+      assertKeyType(type);
+    }
+
+    if (meta) {
+      assert(typeof meta === 'object', 'invalid meta');
+    }
+  },
 
   signData(params: SignDataParams) {
     assert(!!params.keyPair, 'invalid keypair');
@@ -65,6 +80,12 @@ export type GetKeyringParams = {
   derivePath?: string,
 };
 
+export type CreateFromPairParams = {
+  pair: any,
+  meta?: any,
+  type?: string,
+}
+
 export type AddressFromUriParams = GetKeyringParams;
 
 export type AddFromJsonParams = {

package/src/services/keyring/service.ts

@@ -5,6 +5,7 @@ import {
   AddFromJsonParams,
   AddFromMnemonicParams,
   CreateFromUriParams,
+  CreateFromPairParams,
   InitializeParams,
   serviceName,
   validation,
@@ -86,6 +87,18 @@ export class KeyringService {
     );
   }
 
+  createFromPair(params: CreateFromPairParams): KeyringPair {
+    validation.createFromPair(params);
+
+    const {pair, meta, type} = params;
+
+    return this.keyring.createFromPair(
+      pair,
+      meta,
+      type,
+    );
+  }
+
   getKeyringPairJSON(params: CreateFromUriParams): KeyringPair {
     return this.getKeyringPair(params).toJson();
   }

package/src/services/pex/service.ts

@@ -18,30 +18,41 @@ const pex: PEX = new PEX();
  * This is a temporary workaround until the issue is fixed in the @sphereon/pex library
  **/
 export function removeOptionalAttribute(presentationDefinition) {
-  presentationDefinition.input_descriptors.forEach(inputDescriptor => {
+  // Deep clone the presentationDefinition to avoid mutating the original
+  const clonedPresentationDefinition = JSON.parse(
+    JSON.stringify(presentationDefinition),
+  );
+
+  clonedPresentationDefinition.input_descriptors.forEach(inputDescriptor => {
     if (!inputDescriptor.constraints?.fields?.length) {
       return;
     }
+
     // Filter the optional fields
-    // If we include those fields, it might exclude few credentials from the resulsts
-    // e.g: Expiration date as optional, a credenntial without expiration date should be included
     inputDescriptor.constraints.fields =
       inputDescriptor.constraints.fields.filter(
         field => field.optional !== true,
       );
 
-    // Removes the optinal attributes from the fields
-    // It applies in case optional: false
-    // The field is required, but pex doesn't support the attribute
-    inputDescriptor.constraints.fields.forEach(field => {
-      if (field.optional !== undefined) {
-        delete field.optional;
-      }
-    });
-
-    // There is a case where ALL fields are optional
-    // If we remove all fields, it will cause an error with PEX
-    // So, we add a placeholder field to avoid the error
+    inputDescriptor.constraints.fields = inputDescriptor.constraints.fields.map(
+      field => {
+        const updatedField = {...field};
+
+        // Remove the optional attribute if it exists
+        if (updatedField.optional !== undefined) {
+          delete updatedField.optional;
+        }
+
+        // Remove the did format attribute if it exists
+        if (updatedField.filter?.format === 'did') {
+          delete updatedField.filter.format;
+        }
+
+        return updatedField;
+      },
+    );
+
+    // Handle case where all fields are optional
     if (inputDescriptor.constraints.fields.length === 0) {
       inputDescriptor.constraints.fields.push({
         path: ['$.id'],
@@ -49,11 +60,11 @@ export function removeOptionalAttribute(presentationDefinition) {
     }
   });
 
-  if (!presentationDefinition.id) {
-    presentationDefinition.id = 'id';
+  if (!clonedPresentationDefinition.id) {
+    clonedPresentationDefinition.id = 'id';
   }
 
-  return presentationDefinition;
+  return clonedPresentationDefinition;
 }
 
 class PEXService {