@docknetwork/wallet-sdk-wasm 1.5.9 → 1.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.5.9",
+    "version": "1.5.10",
     "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -13,43 +13,23 @@
         "build": "rm -rf lib && rollup -c && node ../../scripts/fix-build-imports.js ./lib"
     },
     "resolutions": {
-        "p-limit": "2.3.0",
-        "@polkadot/wasm-crypto": "6.3.1",
-        "@polkadot/rpc-core": "9.7.1",
-        "@polkadot/api": "9.7.1",
-        "@polkadot/keyring": "10.1.11",
-        "@polkadot/rpc-provider": "9.7.1",
-        "@polkadot/types": "9.7.1",
-        "@polkadot/types-known": "9.7.1",
-        "@polkadot/util": "10.1.11",
-        "@polkadot/util-crypto": "10.1.11"
+        "p-limit": "2.3.0"
     },
     "dependencies": {
         "p-limit": "2.3.0",
         "@astronautlabs/jsonpath": "^1.1.2",
         "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/wallet-sdk-dids": "^1.5.9",
+        "@docknetwork/wallet-sdk-dids": "^1.5.10",
         "@cosmjs/proto-signing": "^0.32.4",
         "@docknetwork/cheqd-blockchain-api": "0.36.1",
         "@docknetwork/cheqd-blockchain-modules": "0.33.0",
-        "@polkadot/api": "9.7.1",
-        "@polkadot/keyring": "10.1.11",
-        "@polkadot/rpc-core": "9.7.1",
-        "@polkadot/rpc-provider": "9.7.1",
-        "@polkadot/types": "9.7.1",
-        "@polkadot/types-known": "9.7.1",
-        "@polkadot/ui-shared": "3.4.1",
-        "@polkadot/util": "10.1.11",
-        "@polkadot/util-crypto": "10.1.11",
-        "@polkadot/wasm-crypto": "6.3.1",
+        "@scure/bip39": "^1.6.0",
+        "@noble/hashes": "1.8.0",
         "@docknetwork/credential-sdk": "0.50.0",
         "@sphereon/oid4vci-client": "^0.16.0",
         "@sphereon/oid4vci-common": "^0.16.0",
         "axios": "^0.25.0",
-        "babel-node": "^0.0.1-security",
-        "bignumber.js": "^9.0.1",
         "json-rpc-2.0": "^0.2.16",
-        "react-native-keychain": "^8.0.0",
         "uuid": "^8.3.2",
         "winston": "^3.3.3",
         "cwait": "1.1.2",

package/readme.md

@@ -1,61 +0,0 @@
-# Dock Wallet SDK
-
-The Dock Wallet SDK provides all the required functions to build a PolkaDot Wallet on top of a [Universal Wallet 2020](https://w3c-ccg.github.io/universal-wallet-interop-spec/) document storage. It supports both Node.js and React Native.
-
-For React Native usage please check [@docknetwork/wallet-sdk-react-native](https://www.npmjs.com/package/@docknetwork/wallet-sdk-react-native)
-
-This is the core package and includes basic functionalities such as:
-- Document storage following [Universal Wallet 2020 spec](https://w3c-ccg.github.io/universal-wallet-interop-spec/)
-- Manage a wallet (CRUD)
-- Manage accounts (CRUD)
-- Fetch account balances
-- Wallet/Account backup
-- Import wallet/accounts
-
-You might require to install extra packages depending on your needs, please refer to:
-- [@docknetwork/wallet-sdk-react-native](https://www.npmjs.com/package/@docknetwork/wallet-sdk-react-native)
-- [@docknetwork/wallet-sdk-dids](https://www.npmjs.com/package/@docknetwork/wallet-sdk-dids)
-- [@docknetwork/wallet-sdk-transactions](https://www.npmjs.com/package/@docknetwork/wallet-sdk-transactions)
-- [@docknetwork/wallet-sdk-credentials](https://www.npmjs.com/package/@docknetwork/wallet-sdk-credentials)
-
-## Installation
-```js
-yarn add @docknetwork/wallet-sdk-core
-
-```
-
-
-## React Native Example
-
-```js
-import {Wallet} from '@docknetwork/wallet-sdk-core/lib/modules/wallet';
-
-const wallet = await Wallet.create();
-
-const account1 = await wallet.accounts.create({
-  name: 'test',
-});
-
-console.log(`Account1 address ${account1.address}`);
-// result: Account1 address 3D1M9UnR684eBfVujjQr6ucPqvXERSxYxcVBFGAhRohhRXxq
-
-// Create account using an existing mnemonic
-const mnemonic =
-  'indicate mention thing discover clarify grief inherit vivid dish health market spoil';
-const account2 = await wallet.accounts.create({
-  name: 'Test',
-  mnemonic,
-});
-
-console.log(`Account2 address ${account2.address}`);
-
-// result: Account2 address 3FENesfZgFmBruv2H9Hc17GmobeTfxFAp8gHKXFmUtA38hcW
-
-// Fetch accounts balance
-const balance = await account1.getBalance();
-
-console.log('Account1 balance', balance);
-
-// result: Account1 balance 0
-
-```

package/src/core/format-utils.test.js

@@ -1,33 +1,6 @@
-import {
-  formatAddress,
-  formatCurrency,
-  formatDate,
-  getPlainDockAmount,
-} from './format-utils';
-
-const sr25519Address = '395pw1L5R4XiScC2BGRrSSSH6fadFuGSTfUcqA5cHPyA21eQ';
-const ed25519Address = '38yWnWt8k3j5BuxssLAH43t5cNevxyShkCAMEx8su3nSsayh';
+import {formatCurrency, formatDate} from './format-utils';
 
 describe('Format util', () => {
-  it('expect to format sr25519 address', () => {
-    expect(formatAddress(sr25519Address)).toBe('395pw1L5R...5cHPyA21eQ');
-  });
-
-  it('expect to format ed25519Address address', () => {
-    expect(formatAddress(ed25519Address)).toBe('38yWnWt8k...8su3nSsayh');
-  });
-
-  it('expect to validate address length', () => {
-    expect(formatAddress(sr25519Address, sr25519Address.length + 10)).toBe(
-      sr25519Address,
-    );
-  });
-
-  it('getPlainDockAmount', () => {
-    const amount = getPlainDockAmount(10);
-    expect(amount.toNumber()).toBe(10000000);
-  });
-
   it('formatCurrency', () => {
     const result = formatCurrency(12.55);
     expect(result).toBe('$12.55');

package/src/core/format-utils.ts

@@ -6,10 +6,6 @@
  */
 
 import assert from 'assert';
-import BigNumber from 'bignumber.js';
-import {isNumberValid} from './validation';
-
-export const DOCK_TOKEN_UNIT = 1000000;
 
 /**
  * Format number as currency
@@ -44,35 +40,6 @@ export function formatCurrency(
   return formatter.format(value);
 }
 
-export function formatAddress(address, size = 19) {
-  assert(!!address, 'address is required');
-  assert(typeof address === 'string', 'address must be a string');
-
-  if (!address || size > address.length) {
-    return address;
-  }
-
-  const offset = size / 2;
-
-  return `${address.substring(0, offset)}...${address.substring(
-    address.length - offset,
-  )}`;
-}
-
-export function formatDockAmount(value) {
-  assert(!!value, 'value is required');
-  assert(isNumberValid(value), 'value is not valid');
-
-  return BigNumber(value).dividedBy(DOCK_TOKEN_UNIT).toNumber();
-}
-
-export function getPlainDockAmount(value) {
-  assert(!!value, 'value is required');
-  assert(isNumberValid(value), 'value is not valid');
-
-  return BigNumber(value).times(DOCK_TOKEN_UNIT);
-}
-
 /**
  *
  * @param date

package/src/core/validation.test.js

@@ -1,41 +1,9 @@
-import BigNumber from 'bignumber.js';
-import {
-  assertAddress,
-  assertTokenAmount,
-  isAddressValid,
-  isNumberValid,
-} from './validation';
+import {isNumberValid} from './validation';
 
 describe('core validation', () => {
-  it('isAddressValid', () => {
-    expect(isAddressValid(' ')).toBeFalsy();
-    expect(isAddressValid('   ')).toBeFalsy();
-    expect(isAddressValid('')).toBeFalsy();
-    expect(isAddressValid(null)).toBeFalsy();
-    expect(isAddressValid(undefined)).toBeFalsy();
-    expect(isAddressValid(123)).toBeFalsy();
-    expect(isAddressValid('address')).toBeTruthy();
-  });
-
   it('isNumberValid', () => {
-    expect(isNumberValid('100000000')).toBeTruthy();
     expect(isNumberValid('this is not valid')).toBeFalsy();
     expect(isNumberValid(false)).toBeFalsy();
     expect(isNumberValid(10)).toBeTruthy();
-    expect(isNumberValid(BigNumber(1))).toBeTruthy();
-  });
-
-  it('assertAddress', () => {
-    expect(() => assertAddress(' ')).toThrow(`invalid address: ${' '}`);
-    expect(() => assertAddress(null)).toThrow('invalid address: null');
-    expect(() => assertAddress('address')).not.toThrow();
-  });
-
-  it('assertTokenAmount', () => {
-    expect(() => assertTokenAmount(' ')).toThrow('invalid token amount');
-    expect(() => assertTokenAmount('abc')).toThrow('invalid token amount');
-    expect(() => assertTokenAmount(null)).toThrow('invalid token amount');
-    expect(() => assertTokenAmount('10')).not.toThrow();
-    expect(() => assertTokenAmount(100)).not.toThrow();
   });
 });

package/src/core/validation.ts

@@ -1,16 +1,11 @@
 // @ts-nocheck
-import BigNumber from 'bignumber.js';
 import assert from 'assert';
 import {KeypairTypes} from '../types';
 
 export {assert};
 
 export function isNumberValid(v: any) {
-  if (v instanceof BigNumber) {
-    return true;
-  }
-
-  return !isNaN(parseInt(v, 10));
+  return typeof v === 'number' && !isNaN(v);
 }
 
 export function assertKeyType(type) {
@@ -24,22 +19,3 @@ export function assertPassword(password) {
   assert(typeof password === 'string', `invalid password: ${password}`);
 }
 
-export function assertTokenAmount(amount) {
-  assert(isNumberValid(amount), 'invalid token amount');
-}
-
-export function assertAddress(address, name = 'address') {
-  assert(isAddressValid(address), `invalid ${name}: ${address}`);
-}
-
-export function isAddressValid(address) {
-  if (!address || typeof address !== 'string') {
-    return false;
-  }
-
-  if (!address.trim()) {
-    return false;
-  }
-
-  return true;
-}

package/src/rpc-server.test.js

@@ -1,15 +1,8 @@
 import {utilCryptoService} from './services/util-crypto/service';
-import {walletService} from './services/wallet';
 
 describe('RpcServer', () => {
-  it('expect to register walletService', async () => {
-    const timestamp = Date.now();
-    const result = await walletService.healthCheck(timestamp);
-    expect(result).toBe(`wallet: ${timestamp}`);
-  });
-
   it('expect to register utilCrypto', async () => {
-    const result = await utilCryptoService.cryptoWaitReady();
-    expect(result).toBe(true);
+    const result = await utilCryptoService.mnemonicGenerate(12);
+    expect(result).toBeDefined();
   });
 });

package/src/rpc-util.js

@@ -3,6 +3,12 @@ import {decryptData, SECURE_JSON_RPC} from './core/crypto';
 import {Logger} from './core/logger';
 
 export function createMethodResolver({service, methodFn, methodName}) {
+  if (methodFn === undefined) {
+    throw new Error(
+      `Resolver is undefined for ${methodName} in ${service.name}`,
+    );
+  }
+
   const methodPath = `${service.name}.${methodName}`;
 
   return {
@@ -58,6 +64,14 @@ export function createRpcService(service) {
   }
 
   return methods.map(methodFn => {
+    if (methodFn === undefined) {
+      throw new Error(
+        `Method is undefined in ${
+          service.name
+        }, available methods: ${Object.keys(service.rpcMethods).join(', ')}`,
+      );
+    }
+
     return createMethodResolver({
       methodFn,
       methodName: methodFn.name,

package/src/services/blockchain/service.ts

@@ -100,6 +100,7 @@ export class BlockchainService {
     }
 
     if (this.cheqdApi && this.cheqdApi.isInitialized()) {
+      Logger.info('Disconnecting from cheqd');
       await this.cheqdApi.disconnect();
     }
 

package/src/services/credential/bbs-revocation.ts

@@ -7,8 +7,9 @@ import {
   VBWitnessUpdateInfo,
   Encoder,
 } from '@docknetwork/crypto-wasm-ts';
+// @ts-ignore
+import {hexToU8a} from '@docknetwork/credential-sdk/utils';
 
-import {hexToU8a} from '@polkadot/util';
 import {
   blockchainService,
 } from '../blockchain/service';

package/src/services/credential/bound-check.test.ts

@@ -374,16 +374,16 @@ describe('Bound check', () => {
   });
 
   describe('isBase64OrDataUrl', () => {
-    it('expect to return true for base64 string', () => {
-      expect(isBase64OrDataUrl('base64string')).toBe(true);
+    it('expect to return true for base64 string', async () => {
+      expect(await isBase64OrDataUrl('SGVsbG8gV29ybGQ=')).toBe(true);
     });
 
-    it('expect to return true for data URL', () => {
-      expect(isBase64OrDataUrl('data:application/octet-stream;base64,base64string')).toBe(true);
+    it('expect to return true for data URL', async () => {
+      expect(await isBase64OrDataUrl('data:application/octet-stream;base64,base64string')).toBe(true);
     });
 
-    it('expect to return false for other strings', () => {
-      expect(isBase64OrDataUrl('http://certs.dock.io/some-key')).toBe(false);
+    it('expect to return false for other strings', async () => {
+      expect(await isBase64OrDataUrl('http://workspace.truvera.io/some-key')).toBe(false);
     });
   });
 });

package/src/services/credential/bound-check.ts

@@ -1,8 +1,8 @@
 import {LegoProvingKey} from '@docknetwork/crypto-wasm-ts/lib/legosnark';
 import {PresentationBuilder} from '@docknetwork/crypto-wasm-ts/lib';
-import {isBase64} from '@polkadot/util-crypto';
 import base64url from 'base64url';
 import {pexToBounds} from './pex-helpers';
+import {utilCryptoService} from '../util-crypto/service';
 
 interface Filter {
   type: string;
@@ -110,9 +110,9 @@ export function blobFromBase64(base64String: string): Uint8Array {
   return base64url.toBuffer(cleanedBase64);
 }
 
-export function isBase64OrDataUrl(str: string): boolean {
+export async function isBase64OrDataUrl(str: string): Promise<boolean> {
   return (
-    isBase64(str) ||
+    (await utilCryptoService.isBase64(str)) ||
     (str as string).indexOf('data:application/octet-stream') > -1
   );
 }
@@ -120,7 +120,7 @@ export function isBase64OrDataUrl(str: string): boolean {
 export async function fetchProvingKey(proofRequest: ProofRequest) {
   let blob: Uint8Array;
 
-  if (isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
+  if (await isBase64OrDataUrl(proofRequest.boundCheckSnarkKey)) {
     console.log('Is base64');
     blob = blobFromBase64(proofRequest.boundCheckSnarkKey);
   } else {

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

@@ -3,13 +3,11 @@ import {credentialService as service} from './service';
 import {validation} from './config';
 import * as credentialUtils from '@docknetwork/credential-sdk/vc';
 import {CredentialServiceRPC} from './service-rpc';
-import {getTestWallet} from '../../test/setup-test-state';
 import {OpenID4VCIClientV1_0_13} from '@sphereon/oid4vci-client';
 import {didService} from '../dids/service';
 
 describe('Credential Service', () => {
   beforeAll(async () => {
-    await getTestWallet();
     const mockAddCredentialToPresent = jest.fn(() => 0);
     const mockAddAttributeToReveal = jest.fn();
     const mockCreatePresentation = jest.fn();

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);
   });
@@ -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();
   });
 });