@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.5.8",
+    "version": "1.5.10",
     "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -13,44 +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.8",
+        "@docknetwork/wallet-sdk-dids": "^1.5.10",
         "@cosmjs/proto-signing": "^0.32.4",
         "@docknetwork/cheqd-blockchain-api": "0.36.1",
-       "@docknetwork/dock-blockchain-api": "0.23.0",
         "@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",
-        "@docknetwork/dock-blockchain-modules": "0.30.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/index.test.js

@@ -1,34 +1,23 @@
 import {NetworkManager} from '../../modules/network-manager';
-import {assertRpcService, mockDockSdkConnection} from '../test-utils';
+import {assertRpcService} from '../test-utils';
 import {validation} from './configs';
 import {blockchainService as service} from './service';
 import {BlockchainServiceRpc} from './service-rpc';
 
-const doConnect = (
-  address = NetworkManager.getInstance().getNetworkInfo().substrateUrl,
-) =>
-  service.init({
-    address,
-  });
-
 describe('DockService', () => {
   it('ServiceRpc', () => {
     assertRpcService(BlockchainServiceRpc, service, validation);
   });
 
   describe('init', () => {
-    afterEach(async () => {
-      await service.disconnect();
-    });
-
     it('connect and disconnect substrate node', async () => {
-      const mock = mockDockSdkConnection();
-      const result = await doConnect();
+      const result = await service.init({
+        cheqdApiUrl: NetworkManager.getInstance().getNetworkInfo().cheqdApiUrl,
+      });
       expect(result).toBe(true);
       expect(service.isBlockchainReady).toBeTruthy();
       await service.disconnect();
       expect(service.isBlockchainReady).toBeFalsy();
-      mock.clear();
     });
   });
 });

package/src/services/blockchain/service.ts

@@ -12,12 +12,6 @@ import {
   WILDCARD,
 } from '@docknetwork/credential-sdk/resolver';
 import {initializeWasm} from '@docknetwork/crypto-wasm-ts/lib/index';
-
-import {DockAPI} from '@docknetwork/dock-blockchain-api';
-import {
-  DockCoreModules,
-  DockDIDModule,
-} from '@docknetwork/dock-blockchain-modules';
 import {EventEmitter} from 'events';
 import {Logger} from '../../core/logger';
 import {once} from '../../modules/event-manager';
@@ -27,47 +21,25 @@ import {InitParams} from './configs';
 export const universalResolverUrl = 'https://uniresolver.truvera.io';
 
 import {
-  CheqdAccumulatorCommon,
-  CheqdAccumulatorId,
-  CheqdAccumulatorPublicKey,
-  DockAccumulatorCommon,
-  DockAccumulatorId,
-  DockAccumulatorPublicKey,
+  AccumulatorCommon,
+  AccumulatorId,
+  AccumulatorPublicKey,
 } from '@docknetwork/credential-sdk/types';
 
 class AnyDIDResolver extends ResolverRouter {
   method = WILDCARD;
 }
 
-const {AccumulatorModule: AccumulatorModuleDock} = DockCoreModules;
-const {AccumulatorModule: AccumulatorModuleCheqd} = CheqdCoreModules;
-
-const TYPES_FOR_DID = {
-  dock: {
-    PublicKey: DockAccumulatorPublicKey,
-    AccumulatorId: DockAccumulatorId,
-    AccumulatorCommon: DockAccumulatorCommon,
-    AccumulatorModule: AccumulatorModuleDock,
-  },
-  cheqd: {
-    PublicKey: CheqdAccumulatorPublicKey,
-    AccumulatorId: CheqdAccumulatorId,
-    AccumulatorCommon: CheqdAccumulatorCommon,
-    AccumulatorModule: AccumulatorModuleCheqd,
-  },
-};
-
 /**
  *
  */
 export class BlockchainService {
   dock;
   modules;
-  didModule;
   cheqdApi;
+  cheqdApiUrl;
   isBlockchainReady = false;
   resolver: any;
-  dockEnabled: boolean;
   static Events = {
     BLOCKCHAIN_READY: 'blockchain-ready',
   };
@@ -82,32 +54,20 @@ export class BlockchainService {
 
   constructor() {
     this.name = 'blockchain';
-    this.dock = new DockAPI();
     this.cheqdApi = new CheqdAPI();
-    this.didModule = new DockDIDModule(this.dock);
-    this.dockModules = new DockCoreModules(this.dock);
     this.cheqdModules = new CheqdCoreModules(this.cheqdApi);
-    this.modules = new MultiApiCoreModules(
-      this.dockEnabled
-        ? [this.dockModules, this.cheqdModules]
-        : [this.cheqdModules],
-    );
+    this.modules = new MultiApiCoreModules([this.cheqdModules]);
     this.emitter = new EventEmitter();
     this.resolver = this.createDIDResolver();
   }
 
   getTypesForDIDOrAccumulator(didOrRegistryId) {
-    const didType = didOrRegistryId
-      .replace('dock:accumulator:', 'accumulator:dock:')
-      .split(':')[1];
-    const chainDidType = !this.dock && didType === 'dock' ? 'cheqd' : didType;
-    const types = TYPES_FOR_DID[chainDidType];
-    if (!types) {
-      throw new APIError(
-        `Unable to use DID type ${didType} for this operation`,
-      );
+    return {
+        PublicKey: AccumulatorPublicKey,
+        AccumulatorId,
+        AccumulatorCommon,
+        AccumulatorModule: this.modules.accumulator,
     }
-    return types;
   }
 
   /**
@@ -135,63 +95,48 @@ export class BlockchainService {
    * @returns
    */
   async init(params: InitParams) {
-    if (this.dock.isConnected) {
-      await this.dock.disconnect();
+    if (!params?.cheqdApiUrl) {
+      throw new Error('cheqdApiUrl is required');
     }
 
     if (this.cheqdApi && this.cheqdApi.isInitialized()) {
+      Logger.info('Disconnecting from cheqd');
       await this.cheqdApi.disconnect();
     }
 
-    Logger.info(`Attempt to initialized substrate at: ${params.address}`);
+    this.modules = new MultiApiCoreModules([this.cheqdModules]);
 
-    this.dockEnabled = !!params.substrateUrl;
+    const checkdApiUrl = params?.cheqdApiUrl;
+    const cheqdNetworkId = params?.networkId;
+    const cheqdMnemonic =
+      params?.cheqdMnemonic || (await utilCryptoService.mnemonicGenerate(12));
 
-    if (this.dockEnabled) {
-      await this.dock.init({
-        address: params.substrateUrl,
-      });
-      Logger.info(`Substrate initialized at: ${params.address}`);
-    }
+    const wallet = await DirectSecp256k1HdWallet.fromMnemonic(cheqdMnemonic, {
+      prefix: 'cheqd',
+    });
 
-    this.modules = new MultiApiCoreModules(
-      this.dockEnabled
-        ? [this.dockModules, this.cheqdModules]
-        : [this.cheqdModules],
-    );
+    const walletAccounts = await wallet.getAccounts();
+    const [{address}] = walletAccounts;
+    console.log('Using cheqd account:', address);
 
-    if (params?.cheqdApiUrl) {
-      const checkdApiUrl = params?.cheqdApiUrl;
-      const cheqdNetworkId = params?.networkId;
-      const cheqdMnemonic =
-        params?.cheqdMnemonic || (await utilCryptoService.mnemonicGenerate(12));
+    Logger.info(
+      `Attempt to initialized cheqd at: ${checkdApiUrl} with networkId: ${cheqdNetworkId}`,
+    );
+    Logger.info(`Using cheqd account: ${address}`);
 
-      const wallet = await DirectSecp256k1HdWallet.fromMnemonic(cheqdMnemonic, {
-        prefix: 'cheqd',
+    try {
+      await this.cheqdApi.init({
+        wallet,
+        url: checkdApiUrl,
+        network: cheqdNetworkId,
       });
-
-      const walletAccounts = await wallet.getAccounts();
-      const [{address}] = walletAccounts;
-      console.log('Using cheqd account:', address);
-
-      Logger.info(
-        `Attempt to initialized cheqd at: ${checkdApiUrl} with networkId: ${cheqdNetworkId}`,
-      );
-      Logger.info(`Using cheqd account: ${address}`);
-
-      try {
-        await this.cheqdApi.init({
-          wallet,
-          url: checkdApiUrl,
-          network: cheqdNetworkId,
-        });
-        Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
-      } catch (err) {
-        Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`);
-      }
+      Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
+    } catch (err) {
+      console.error(err);
+      debugger;
+      Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`);
     }
 
-    this.address = params.address;
 
     this.resolver = this.createDIDResolver();
 
@@ -214,10 +159,6 @@ export class BlockchainService {
   async disconnect() {
     let result;
 
-    if (this.dockEnabled) {
-      result = await this.dock.disconnect();
-    }
-
     if (this.cheqdApi && this.cheqdApi.isInitialized()) {
       result = await this.cheqdApi.disconnect();
     }
@@ -246,7 +187,7 @@ export class BlockchainService {
   }
 
   async getAddress() {
-    return this.dock.address;
+    return this.cheqdApiUrl;
   }
 
   _setBlockchainReady(isBlockchainReady) {

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