@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/src/services/credential/service.ts

@@ -9,6 +9,7 @@ import {
 import {OpenID4VCIClientV1_0_13} from '@sphereon/oid4vci-client';
 import {Alg} from '@sphereon/oid4vci-common';
 import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
+import {hexToU8a} from '@docknetwork/credential-sdk/utils';
 import {
   VerifiablePresentation,
   Presentation,
@@ -117,13 +118,15 @@ class CredentialService {
       vp.setHolder(keyDoc.controller);
     }
 
-    keyDoc.keypair = keyDocToKeypair(keyDoc, blockchainService.dock);
+    const keyPair = getKeypairFromDoc(keyDoc);
+    keyPair.signer = keyPair.signer();
+    const suite = await getSuiteFromKeyDoc(keyPair);
 
     if (shouldSkipSigning) {
       return vp.toJSON();
     }
 
-    return vp.sign(keyDoc, challenge, domain, blockchainService.resolver);
+    return vp.sign(suite, challenge, domain, blockchainService.resolver);
   }
 
   async verifyPresentation({ presentation, options }: any) {

package/src/services/credential/utils.js

@@ -1,13 +1,22 @@
 import * as bs58 from 'base58-universal';
-import {Bls12381G2KeyPairDock2022} from '@docknetwork/credential-sdk/vc/crypto';
-import {getKeyring} from '../keyring/service';
+import {
+  Bls12381BBSKeyPairDock2023,
+  Bls12381G2KeyPairDock2022,
+  Bls12381BBDT16KeyPairDock2024,
+} from '@docknetwork/credential-sdk/vc/crypto';
+import {randomAsHex} from '@docknetwork/credential-sdk/utils';
+import x25519KeyAgreementKey2020 from '@digitalbazaar/x25519-key-agreement-key-2020';
+import x25519KeyAgreementKey2019 from '@digitalbazaar/x25519-key-agreement-key-2019';
+import ed25519VerificationKey2018 from '@digitalbazaar/ed25519-verification-key-2018';
+import ed25519VerificationKey2020 from '@digitalbazaar/ed25519-verification-key-2020';
+
+import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
+
+export async function keyDocToKeypair(keyDoc) {
+  if (keyDoc.keypair) {
+    return keyDoc;
+  }
 
-const docToKeyMap = {
-  Sr25519VerificationKey2020: 'sr25519',
-  Ed25519VerificationKey2018: 'ed25519',
-};
-export function keyDocToKeypair(keyDoc, dock) {
-  // For now we expect multibase to just be b58, this needs fixing later if/when we support more keys
   const {
     type,
     privateKeyBase58,
@@ -15,25 +24,58 @@ export function keyDocToKeypair(keyDoc, dock) {
     privateKeyMultibase,
     publicKeyMultibase,
   } = keyDoc;
-  const privateKeyEncoded = privateKeyBase58 || privateKeyMultibase.substr(1);
+
+  const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
+  const privateKeyEncoded =
+    privateKeyBase58 || (privateKeyMultibase && privateKeyMultibase.substr(1));
+  if (!privateKeyEncoded) {
+    throw new Error(
+      `No private key in document found, this should not happen. Got: ${JSON.stringify(
+        keyDoc,
+        null,
+        2,
+      )}`,
+    );
+  }
+
   const privateKeyBytes = bs58.decode(privateKeyEncoded);
+  const publicKeyBytes = bs58.decode(publicKeyEncoded);
 
   if (type === 'Bls12381G2VerificationKeyDock2022') {
     return new Bls12381G2KeyPairDock2022(keyDoc);
+  } else if (type === 'Bls12381BBSVerificationKeyDock2023') {
+    return new Bls12381BBSKeyPairDock2023(keyDoc);
+  } else if (type === 'Bls12381BBDT16VerificationKeyDock2024') {
+    return new Bls12381BBDT16KeyPairDock2024(keyDoc);
+  } else if (
+    type === 'Ed25519VerificationKey2020' ||
+    type === 'Ed25519VerificationKey2018'
+  ) {
+    const key = new Ed25519Keypair(randomAsHex(32));
+    key.keyPair.publicKey = publicKeyBytes;
+    key.keyPair.secretKey = privateKeyBytes;
+    return key;
   } else {
-    const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
-    const keyType = docToKeyMap[type];
-    if (!keyType) {
-      throw new Error(`Unsupported key type: ${type}`);
-    }
-
-    return getKeyring().createFromPair(
-      {
-        publicKey: bs58.decode(publicKeyEncoded),
-        secretKey: privateKeyBytes,
-      },
-      {},
-      keyType,
-    );
+    throw new Error(`Unsupported key type: ${type}`);
+  }
+}
+
+const keyConstructors = {
+  Ed25519VerificationKey2018: keypairOptions =>
+    new ed25519VerificationKey2018.Ed25519VerificationKey2018(keypairOptions),
+  Ed25519VerificationKey2020: keypairOptions =>
+    new ed25519VerificationKey2020.Ed25519VerificationKey2020(keypairOptions),
+  X25519KeyAgreementKey2019: keypairOptions =>
+    new x25519KeyAgreementKey2019.X25519KeyAgreementKey2019(keypairOptions),
+  X25519KeyAgreementKey2020: keypairOptions =>
+    new x25519KeyAgreementKey2020.X25519KeyAgreementKey2020(keypairOptions),
+};
+
+export function getKeypairFromDoc(keypairOptions) {
+  const {type} = keypairOptions;
+  const keyConstructor = keyConstructors[type];
+  if (!keyConstructor) {
+    throw new Error(`Unrecognized keypair type to construct: ${type}`);
   }
+  return keyConstructor(keypairOptions);
 }

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

@@ -3,14 +3,10 @@ import {DIDServiceRPC} from './service-rpc';
 import {didService as service} from './service';
 import {validation} from './config';
 import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
-import {getTestWallet} from '../../test/setup-test-state';
 import {blockchainService} from '../blockchain/service';
+import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
 describe('DID Service', () => {
-  beforeAll(async () => {
-    await getTestWallet();
-  });
-
   it('ServiceRpc', () => {
     assertRpcService(DIDServiceRPC, service, validation);
   });
@@ -100,7 +96,7 @@ describe('DID Service', () => {
   it('expect to get did document', async () => {
     const document = 'document';
     jest
-      .spyOn(blockchainService.didModule, 'getDocument')
+      .spyOn(blockchainService.modules.did, 'getDocument')
       .mockResolvedValue(document);
 
     const result = await service.getDidDockDocument(
@@ -121,25 +117,18 @@ describe('DID Service', () => {
     expect(keyDoc.privateKeyMultibase).toBeDefined();
   });
 
-  it('expect to generateKeyDoc with keyPair', async () => {
+  it('expect to deriveKeyDoc', async () => {
     const controller =
       'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQ';
-    const keyPairJSON = {
-      encoded:
-        'MFMCAQEwBQYDK2VwBCIEIJDIpsaUjZCkVkPmBPqKD0dgu59F8ks4yepJKNFQkz+A/fYvnshD7g1RpaSXuGcLytu6fN/P/PGt2ahhH2Bkh0GhIwMhAP32L57IQ+4NUaWkl7hnC8rbunzfz/zxrdmoYR9gZIdB',
-      encoding: {content: ['pkcs8', 'ed25519'], type: ['none'], version: '3'},
-      address: '3CGqgBTzZEPyhVTjpWdX5z2uDQ6hxEUALcZ6HthscNnVrKy7',
-      meta: {},
-    };
 
-    const keyDoc = await service.generateKeyDoc({
+    const {keyPair} = Ed25519Keypair.random();
+
+    const derivedKeyDoc = await service.deriveKeyDoc({
       controller,
-      keyPairJSON,
+      pair: keyPair,
     });
 
-    expect(keyDoc.controller).toEqual(controller);
-    expect(keyDoc.privateKeyMultibase).toEqual(
-      'z3ttk77Si8AUHHGAGLWue3qZacSgZDtRRCbd75Bmujx2qstznWv4ZRWtCjEKcJAUUufQpSsurEAJ47mYYKPwQnA2C',
-    );
+    expect(derivedKeyDoc.controller).toEqual(controller);
+    expect(derivedKeyDoc.privateKeyMultibase).toBeDefined();
   });
 });

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.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,13 +19,13 @@ 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 =
@@ -84,34 +83,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}) {
@@ -137,7 +118,7 @@ class DIDService {
   async getDidDockDocument(did) {
     assert(!!did, 'DID is required');
     const dock = blockchainService.dock;
-    const result = await blockchainService.didModule.getDocument(did);
+    const result = await blockchainService.modules.did.getDocument(did);
     return result;
   }
 }

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,29 +1,21 @@
-import {keyringService} from './keyring/service';
 import {blockchainService} from './blockchain/service';
-import {substrateService} from './substrate/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';
 import {credentialService} from './credential/service';
 import {relayService} from './relay-service/service';
 import {pexService} from './pex/service';
-import {trustRegistryService} from './trust-registry/service';
 import {edvService} from './edv/service';
 
 export default [
-  keyringService,
   blockchainService,
-  substrateService,
   walletService,
-  polkadotService,
   utilCryptoService,
   storageService,
   didService,
   credentialService,
   relayService,
   pexService,
-  trustRegistryService,
   edvService,
 ];

package/src/services/pex/service.ts

@@ -105,12 +105,18 @@ class PEXService {
 
   presentationFrom(params: CreatePresentationParams) {
     const {credentials, presentationDefinition, holderDID} = params;
-    const result: IPresentation = pex.presentationFrom(
+    const evaluateResult = pex.evaluateCredentials(
       removeOptionalAttribute(presentationDefinition),
       credentials,
       holderDID,
     );
 
+    const result: IPresentation = pex.presentationFrom(
+      presentationDefinition,
+      evaluateResult.verifiableCredential,
+      holderDID,
+    );
+
     return result;
   }
 }

package/src/services/test-utils.js

@@ -1,22 +1,6 @@
-import {cryptoWaitReady} from '@polkadot/util-crypto';
 import assert from 'assert';
-import BigNumber from 'bignumber.js';
-import {DOCK_TOKEN_UNIT} from '../core/format-utils';
-import {TestFixtures} from '../fixtures';
 import {NetworkManager} from '../modules/network-manager';
-import {keyringService} from './keyring';
 import {RpcService} from './rpc-service-client';
-import {walletService} from './wallet';
-import Keyring from '@polkadot/keyring';
-import {blockchainService} from './blockchain/service';
-
-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';
@@ -34,105 +18,6 @@ export const TEST_SCHEMA_METADATA = {
   },
 };
 
-let mockTransactionError;
-
-export const setMockTransactionError = error => {
-  mockTransactionError = error;
-};
-
-export async function mockDockService() {
-  await cryptoWaitReady();
-
-  await keyringService.initialize({
-    ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
-  });
-
-  let sdkMock;
-
-  if (API_MOCK_DISABLED) {
-    return blockchainService.init({
-      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
-    });
-  } else {
-    sdkMock = mockDockSdkConnection();
-    await blockchainService.init({
-      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
-    });
-  }
-
-  const _dockSdk = blockchainService.dock;
-
-  blockchainService.isDockReady = true;
-
-  blockchainService.dock = {
-    api: {
-      events: {
-        system: {
-          ExtrinsicFailed: {
-            is: event => !!mockTransactionError,
-          },
-        },
-      },
-      query: {
-        system: {
-          account: jest.fn().mockImplementation(() => ({
-            data: {
-              free: BigNumber(TestFixtures.account1.balance * DOCK_TOKEN_UNIT),
-            },
-          })),
-        },
-      },
-      revocation: {
-        getIsRevoked: jest.fn().mockImplementation(() => false),
-      },
-      tx: {
-        balances: {
-          transfer: jest.fn().mockImplementation(() => ({
-            paymentInfo: () => ({
-              partialFee: BigNumber(TEST_FEE_AMOUNT * DOCK_TOKEN_UNIT),
-            }),
-            signAndSend: (account, callback) => {
-              callback({
-                status: {
-                  isInBlock: true,
-                  isFinalized: true,
-                  toHex: () => 'hash',
-                },
-                events: [
-                  {
-                    event: {
-                      data: [mockTransactionError],
-                    },
-                  },
-                ],
-              });
-
-              return Promise.resolve({});
-            },
-          })),
-        },
-      },
-    },
-    trustRegistry: {
-      registriesInfo: jest.fn().mockImplementation(() => TEST_TRUST_REGISTRIES),
-      registrySchemasMetadata: jest
-        .fn()
-        .mockImplementation(() => TEST_SCHEMA_METADATA),
-    },
-    init: jest.fn().mockImplementation(() => Promise.resolve({})),
-    disconnect: jest.fn(),
-    setAccount: jest.fn(),
-  };
-
-  return () => {
-    blockchainService.dock = _dockSdk;
-    if (sdkMock) {
-      sdkMock.clear();
-    }
-    blockchainService.disconnect();
-  };
-}
-
 let walletCreated;
 
 export async function setupTestWallet() {
@@ -142,101 +27,9 @@ 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;
 }
 
-export function mockDockSdkConnection(connectionError) {
-  const result = 'result';
-  const dock = blockchainService.dock;
-  const mocks = [
-    jest.spyOn(dock, 'init').mockImplementation(() => {
-      if (connectionError) {
-        return Promise.reject(connectionError);
-      }
-
-      return Promise.resolve(result);
-    }),
-    jest.spyOn(dock, 'disconnect').mockReturnValue(Promise.resolve(true)),
-  ];
-
-  let currentAccount;
-
-  blockchainService.dock = {
-    ...dock,
-    setAccount(account) {
-      currentAccount = account;
-    },
-    did: {
-      new: () => {
-        if (
-          currentAccount &&
-          currentAccount.address === TestFixtures.noBalanceAccount.address
-        ) {
-          throw new Error(
-            '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low',
-          );
-        }
-        return {
-          txHash: 'hash',
-        };
-      },
-      getDocument: () => ({
-        '@context': ['https://www.w3.org/ns/did/v1'],
-        assertionMethod: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        authentication: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        capabilityInvocation: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-        ],
-        controller: [
-          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-        ],
-        id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-        publicKey: [
-          {
-            controller:
-              'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-            id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
-            publicKeyBase58: '8UDojkFBh5RopLKZredz8uVZV5U579voUwQFyYDmgBM3',
-            type: 'Sr25519VerificationKey2020',
-          },
-        ],
-      }),
-    },
-    keyring: {
-      createFromPair: jest.fn(() => {
-        const kr = new Keyring();
-        return kr.createFromUri('//Alice');
-      }),
-    },
-  };
-
-  return {
-    result,
-    clear: () => mocks.forEach(mock => mock.mockClear()),
-  };
-}
-
 export async function getPromiseError(func) {
   try {
     return await func();