@docknetwork/wallet-sdk-core 1.5.9 → 1.5.11

package/src/credential-provider.test.ts

@@ -9,22 +9,56 @@ import {IWallet, createWallet} from './wallet';
 import biometricsBBSRevocation from './fixtures/biometrics-credential-bbs-revocation.json';
 import customerCredential from './fixtures/customer-credential.json';
 import {credentialServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/credential';
-import {createDataStore} from '@docknetwork/wallet-sdk-data-store-typeorm/src'
+import {createDataStore} from '@docknetwork/wallet-sdk-data-store-web/src'
+import {blockchainService} from '@docknetwork/wallet-sdk-wasm/src/services/blockchain';
+
+jest.mock('@docknetwork/wallet-sdk-wasm/src/services/blockchain', () => ({
+  blockchainService: {
+    init: jest.fn().mockResolvedValue(true),
+    ensureBlockchainReady: jest.fn().mockResolvedValue(true),
+    isApiConnected: jest.fn().mockReturnValue(true),
+    isBlockchainReady: true,
+  },
+}));
 
 describe('CredentialProvider', () => {
   let wallet: IWallet;
   let provider: ICredentialProvider;
+  let testId = 0;
 
   beforeEach(async () => {
+    jest.clearAllMocks();
+    jest.spyOn(credentialServiceRPC, 'verifyCredential').mockImplementation(async () => {
+      return {
+        verified: true,
+      };
+    });
+
     wallet = await createWallet({
       dataStore: await createDataStore({
-        databasePath: ':memory:',
+        databasePath: `:memory:${testId++}`,
       }),
     });
 
     provider = createCredentialProvider({wallet});
   });
 
+  afterEach(async () => {
+    if (wallet) {
+      if (wallet.networkCheckInterval) {
+        clearInterval(wallet.networkCheckInterval);
+      }
+
+      if (wallet.dataStore && wallet.dataStore.documents) {
+        await wallet.dataStore.documents.removeAllDocuments();
+      }
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    jest.restoreAllMocks();
+  });
+
   describe('addCredential', () => {
     it('should add a credential to the wallet', async () => {
       await provider.addCredential({
@@ -49,6 +83,9 @@ describe('CredentialProvider', () => {
       await provider.addCredential({
         ...biometricsBBSRevocation,
       });
+      
+      await new Promise(resolve => setTimeout(resolve, 500));
+      jest.clearAllMocks();
     });
 
     it('should create credential status doc with verified status', async () => {
@@ -79,7 +116,8 @@ describe('CredentialProvider', () => {
           };
         });
 
-      const statusDocs = await provider.syncCredentialStatus({});
+      // Force re-fetch by passing forceFetch option
+      const statusDocs = await provider.syncCredentialStatus({forceFetch: true});
 
       expect(statusDocs.length).toBe(2);
 
@@ -88,7 +126,7 @@ describe('CredentialProvider', () => {
       }
     });
 
-    it('should not call verifyCredential twice', async () => {
+    it('should not call verifyCredential twice for same credential', async () => {
       jest
         .spyOn(credentialServiceRPC, 'verifyCredential')
         .mockImplementation(async () => {
@@ -97,13 +135,21 @@ describe('CredentialProvider', () => {
           };
         });
 
-      // first call will do actual fetch
-      await provider.syncCredentialStatus({});
-      // additional calls will use cached data
+      // Force initial fetch to ensure clean state
+      await provider.syncCredentialStatus({forceFetch: true});
+      
+      // Verify initial calls
+      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(2);
+      
+      // Clear mock to track only subsequent calls
+      jest.clearAllMocks();
+      
+      // Second call should use cached data
       const statusDocs = await provider.syncCredentialStatus({});
-
+      
       expect(statusDocs.length).toBe(2);
-      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(2);
+      // Should not call verifyCredential at all since data is already cached
+      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(0);
 
       for (const statusDoc of statusDocs) {
         expect(statusDoc.status).toBe(CredentialStatus.Verified);
@@ -119,8 +165,11 @@ describe('CredentialProvider', () => {
           };
         });
 
-      // load data into cache
-      await provider.syncCredentialStatus({});
+      // Force initial fetch to ensure clean state
+      await provider.syncCredentialStatus({forceFetch: true});
+      
+      // Verify initial calls
+      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(2);
 
       // update statusDoc updateAt to 25 hours ago
       const statusDoc = await wallet.getDocumentById(
@@ -131,12 +180,16 @@ describe('CredentialProvider', () => {
       ).toISOString();
       await wallet.updateDocument(statusDoc);
 
+      // Clear mock to count only the next calls
+      jest.clearAllMocks();
+
       const statusDocs = await provider.syncCredentialStatus({});
 
       expect(statusDocs.length).toBe(2);
 
-      // Expect to have a second status fetch for the customerCredential
-      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(3);
+      // Expect only one call for the expired customerCredential
+      // The biometricsBBSRevocation should use cached data
+      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(1);
 
       for (const statusDoc of statusDocs) {
         expect(statusDoc.status).toBe(CredentialStatus.Verified);
@@ -163,6 +216,45 @@ describe('CredentialProvider', () => {
       }
     });
 
+    it('should return cached status with unable_to_refresh_status warning when verification fails', async () => {
+      // First, sync to create initial status documents
+      jest
+        .spyOn(credentialServiceRPC, 'verifyCredential')
+        .mockImplementation(async () => {
+          return {
+            verified: true,
+          };
+        });
+
+      await provider.syncCredentialStatus({forceFetch: true});
+      
+      // Clear mocks
+      jest.clearAllMocks();
+
+      // Now simulate a network error during verification
+      jest
+        .spyOn(credentialServiceRPC, 'verifyCredential')
+        .mockImplementation(async () => {
+          throw new Error('Network error: Unable to connect to blockchain');
+        });
+
+      // Force fetch to trigger the error scenario
+      const statusDocs = await provider.syncCredentialStatus({forceFetch: true});
+
+      expect(statusDocs.length).toBe(2);
+
+      // Check that status documents retain their previous status with warning
+      for (const statusDoc of statusDocs) {
+        // The status should remain as 'verified' from the cached value
+        expect(statusDoc.status).toBe(CredentialStatus.Verified);
+        // The warning field should be added
+        expect(statusDoc.warning).toBe('unable_to_refresh_status');
+      }
+
+      // Verify that verifyCredential was called despite the error
+      expect(credentialServiceRPC.verifyCredential).toHaveBeenCalledTimes(2);
+    });
+
     afterEach(() => {
       (credentialServiceRPC.verifyCredential as any).mockReset();
     });

package/src/credential-provider.ts

@@ -130,10 +130,25 @@ export async function isValid({
       status: CredentialStatus.Verified,
     };
   } catch (err) {
+    // Handle unknown error, when we can't determine the status
+    // Potential reasons can be network error, blockchain offline, internal SDK error
     console.error(err);
 
+    // in this case we return the cached status if possible
+    // It will avoid showing unknown status in case of a network error
+    const statusDoc = await wallet.getDocumentById(`${credential.id}#status`);
+
+    if (statusDoc) {
+      return {
+        ...statusDoc,
+        warning: 'unable_to_refresh_status',
+      };
+    }
+
+    // Return pending status
+    // As we can't determine the status, and there is no cached status
     return {
-      status: CredentialStatus.Invalid,
+      status: CredentialStatus.Pending,
       error: err.toString(),
     };
   }
@@ -188,6 +203,7 @@ type CredentialStatusDocument = {
   id: string;
   status: string;
   error: string;
+  warning?: string;
 };
 
 /**
@@ -268,6 +284,7 @@ async function syncCredentialStatus({
     const result = await isValid({credential, wallet});
     statusDoc.status = result?.status;
     statusDoc.error = result?.error;
+    statusDoc.warning = result?.warning;
     statusDoc.updatedAt = new Date().toISOString();
 
     await wallet.updateDocument(statusDoc);

package/src/did-provider.ts

@@ -136,8 +136,8 @@ export async function createDIDKey({wallet, name, derivePath=undefined, type=und
     name,
   });
 
-  await wallet.add(keyDoc);
-  await wallet.add(didDocumentResolution);
+  await wallet.addDocument(keyDoc);
+  await wallet.addDocument(didDocumentResolution);
 
   return {
     keyDoc,

package/src/ecosystem-tools.ts

@@ -1,5 +1,6 @@
 import assert from 'assert';
 import axios from 'axios';
+import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
 
 // TODO: FIXME: this wont work for other staging envs
 function getApiURL(networkId) {
@@ -58,3 +59,31 @@ export async function getVerifiers({trustRegistryId, issuerDID, schemaId, networ
     return [];
   }
 }
+
+export async function getMetadata(govFramework: string): Promise<any> {
+  try {
+    const metadataURL = await utilCryptoService.hexToString(govFramework);
+    const response = await axios.get(metadataURL);
+    return response.data;
+  } catch (e) {
+    console.log('error: ', e);
+  }
+
+  return {};
+}
+
+export async function formatEcosystemData(ecosystems: any): Promise<any[]> {
+  const formattedEcosystems = [];
+  const ecosystemsList: any = Object.entries(ecosystems);
+
+  for (let i = 0; i < ecosystemsList.length; i++) {
+    let ecosystemData: any = {};
+    ecosystemData.trustRegistryId = ecosystemsList[i][0];
+    ecosystemData = {...ecosystemData, ...ecosystemsList[i][1]};
+
+    const metadata = await getMetadata(ecosystemsList[i][1]?.govFramework);
+    formattedEcosystems.push({...ecosystemData, ...metadata});
+  }
+
+  return formattedEcosystems;
+}

package/src/network-resolver.ts

@@ -3,9 +3,7 @@ import {
   DocumentNetworkResolver,
   DocumentResolverProps,
   DocumentResolverResult,
-  WalletDocument,
 } from '@docknetwork/wallet-sdk-data-store/src/types';
-import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
 
 type ResolverResult = string | null;
 
@@ -116,42 +114,8 @@ export async function didResolver({
   return null;
 }
 
-export async function accountResolver({
-  document,
-  dataStore,
-}: DocumentResolverProps): Promise<ResolverResult> {
-  if (!document) {
-    return null;
-  }
-
-  const isAddress = Array.isArray(document.type)
-    ? document.type.includes('Address')
-    : document.type === 'Address';
-
-  if (!isAddress) {
-    return null;
-  }
-
-  const addressPrefixList = dataStore.networks.map(
-    network => network?.configs?.addressPrefix,
-  );
-
-  const addressPrefix = await utilCryptoService.getAddressPrefix({
-    address: document.id,
-    startPrefix: Math.min(...addressPrefixList),
-    endPrefix: Math.max(...addressPrefixList),
-  });
-
-  const network = dataStore.networks.find(
-    item => item.configs?.addressPrefix === addressPrefix,
-  );
-
-  return network?.id;
-}
-
 const resolvers = [
   credentialResolver,
-  accountResolver,
   didResolver,
   proofRequestResolver,
 ];

package/src/types.ts

@@ -1,15 +1,11 @@
 import {
   DataStore,
-  DataStoreConfigs,
   DocumentResolverResult,
   WalletDocument,
 } from '@docknetwork/wallet-sdk-data-store/src/types';
-import {Accounts} from '@docknetwork/wallet-sdk-wasm/src/modules/accounts';
 import {EventEmitter} from 'events';
 
 export interface IV1Wallet {
-  accounts: Accounts;
-
   getStatus: () => string;
   setStatus: (status: string) => void;
   eventManager: EventEmitter;
@@ -70,7 +66,7 @@ export type IWallet = {
   getNetworkId: () => string;
   resolveDocumentNetwork: (document: any) => Promise<DocumentResolverResult>;
   dataStore: DataStore;
-  networkCheckInterval?: NodeJS.Timeout;
+  networkCheckInterval?: NodeJS.Timeout | number;
 } & IV1Wallet;
 
 export type CrateWalletWithDataStore = {

package/src/verification-controller.test.ts

@@ -11,7 +11,7 @@ import iiwTemplate from './fixtures/iiw-template.json';
 import anyCredentialProofRequest from './fixtures/any-credential-proof-request.json';
 import universityDegreeProofRequest from './fixtures/university-degree-proof-request.json';
 import {createDIDProvider, IDIDProvider} from './did-provider';
-import {WalletEvents} from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
+import {WalletEvents} from '@docknetwork/wallet-sdk-core/src/wallet';
 import {replaceResponseURL} from './helpers';
 import {createDataStore} from '@docknetwork/wallet-sdk-data-store-typeorm/src';
 

package/src/wallet-wasm.ts

@@ -1,9 +1,8 @@
 import { blockchainService } from '@docknetwork/wallet-sdk-wasm/src/services/blockchain';
-import { keyringService } from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
 import { utilCryptoService } from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
 
 import { Network } from '@docknetwork/wallet-sdk-data-store/src/types';
-import { WalletEvents } from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
+import { WalletEvents } from '@docknetwork/wallet-sdk-core/src/wallet';
 import { captureException } from './helpers';
 import { IWallet } from './types';
 
@@ -50,10 +49,6 @@ export async function setBlockchainNetwork(wallet: IWallet) {
     await wallet.addDocument(cheqdMnemonicDoc);
   }
 
-  await keyringService.initialize({
-    ss58Format: networkConfigs.addressPrefix,
-  });
-
   let connectionInProgress = false;
 
   const initializeBlockchain = () => {
@@ -102,7 +97,6 @@ export async function setBlockchainNetwork(wallet: IWallet) {
 }
 
 export async function initWalletWasm(wallet: IWallet) {
-  await utilCryptoService.cryptoWaitReady();
   const network = wallet.dataStore.network;
 
   if (isBlockchainNetwork(network)) {

package/src/wallet.ts

@@ -1,8 +1,6 @@
 import {CreateWalletProps, IWallet} from './types';
-import {toV1Wallet} from './v1-helpers';
 import {initWalletWasm} from './wallet-wasm';
 import {EventEmitter} from 'events';
-import {WalletEvents} from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
 import {walletService} from '@docknetwork/wallet-sdk-wasm/src/services/wallet';
 import {importUniversalWalletDocuments} from '@docknetwork/wallet-sdk-data-store/src/helpers';
 import {ensureDID} from './did-provider';
@@ -23,6 +21,26 @@ export function ensureDocumentContext(document) {
   };
 }
 
+
+export type WalletStatus = 'closed' | 'loading' | 'ready' | 'error';
+
+export type KeypairType = 'sr25519' | 'ed25519' | 'ecdsa';
+
+export const WalletEvents = {
+  ready: 'ready',
+  error: 'error',
+  migrated: 'migrated',
+  statusUpdated: 'status-updated',
+  documentAdded: 'document-added',
+  documentUpdated: 'document-updated',
+  documentRemoved: 'document-removed',
+  walletDeleted: 'wallet-deleted',
+  walletImported: 'wallet-imported',
+  networkUpdated: 'network-updated',
+  networkConnected: 'network-connected',
+  networkError: 'network-error',
+};
+
 /**
  * Create wallet
  *
@@ -138,21 +156,19 @@ export async function createWallet({
     },
   } as IWallet;
 
-  const v1Wallet = await toV1Wallet(wallet);
-
-  await initWalletWasm(v1Wallet);
+  await initWalletWasm(wallet);
 
   await ensureDID({
-    wallet: v1Wallet,
+    wallet,
   });
 
   [WalletEvents.networkUpdated, WalletEvents.walletDeleted].forEach(event =>
     eventEmitter.on(event, () => {
       ensureDID({
-        wallet: v1Wallet,
+        wallet,
       });
     }),
   );
 
-  return v1Wallet;
+  return wallet;
 }