@docknetwork/wallet-sdk-core 1.5.8 → 1.5.10

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/credentials/oidvc.test.ts

@@ -3,18 +3,16 @@ import {
   getAuthURL,
   decodeRequestJWT,
   getPresentationSubmision,
-} from './oidvc'; // replace with your actual file path
+} from './oidvc';
 import {credentialServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/credential';
 import {MetadataClient} from '@sphereon/oid4vci-client';
 import jwtDecode from 'jwt-decode';
 import axios from 'axios';
-import {pexService} from '@docknetwork/wallet-sdk-wasm/src/services/pex';
 
 jest.mock('@docknetwork/wallet-sdk-wasm/src/services/credential');
 jest.mock('@sphereon/oid4vci-client');
 jest.mock('jwt-decode');
 jest.mock('axios');
-jest.mock('@docknetwork/wallet-sdk-wasm/src/services/pex');
 
 describe('acquireOpenIDCredentialFromURI', () => {
   const didProvider: any = {
@@ -99,14 +97,71 @@ describe('decodeRequestJWT', () => {
 
 describe('getPresentationSubmision', () => {
   it('should get presentation submission', async () => {
-    const credentials = [{id: 'credential-1'}];
-    const presentationDefinition = {id: 'presentation-definition-1'};
-    const holderDID = 'did:example:123';
-    const presentationSubmission = {definition_id: 'presentation-submission-1'};
+    const credentials = [
+      {
+        '@context': [
+          'https://www.w3.org/2018/credentials/v1',
+          'https://ld.truvera.io/credentials/extensions-v1',
+          {
+            BasicCredential: 'dk:BasicCredential',
+            dk: 'https://ld.truvera.io/credentials#',
+          },
+        ],
+        id: 'https://creds-testnet.truvera.io/8afcb0925ad0d31c6afcc7fdec040f3b6c8260c20cdc6da5042307a9fa0dd7a6',
+        type: ['VerifiableCredential', 'BasicCredential'],
+        credentialSubject: {
+          id: 'did:key:z6MkkS7LbdxSqP8WM5GfsXiNwZC6Ve33aj83eEyzsFGphepp',
+          name: 'Test Credential',
+        },
+        issuanceDate: '2025-02-22T19:14:04.108Z',
+        issuer: {
+          name: 'Quotient Credit Union',
+          description: 'Quotient Credit Union is the credit union.',
+          logo: 'https://img.dock.io/06d78272268c606a172d5fd1cd559b46',
+          id: 'did:cheqd:testnet:5ad9c962-74e7-4857-891e-95e4a3b035d0',
+        },
+        name: 'Test Credential',
+        proof: {
+          type: 'Ed25519Signature2018',
+          created: '2025-05-29T18:48:19Z',
+          verificationMethod:
+            'did:cheqd:testnet:5ad9c962-74e7-4857-891e-95e4a3b035d0#keys-1',
+          proofPurpose: 'assertionMethod',
+          jws: 'eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..c5vxz6GKOuWykNKuNVqZ4giOplR3V8YVsJ5Ej4i5Dk3urVFd2ODsAkcu5Th7qWJrD5L3zEJzGEvlUbtRFCS1BQ',
+        },
+      },
+    ];
+    const presentationDefinition = {
+      id: '94d240d2-b70f-412e-8331-1b610407cce6',
+      name: 'Verificação de maioridade',
+      purpose: 'Verificação de maioridade',
+      input_descriptors: [
+        {
+          id: 'OpenFinanceCredentialV2',
+          name: 'Verificação de maioridade',
+          purpose: 'Verificação de maioridade',
+          constraints: {
+            fields: [
+              {
+                path: ['$.credentialSubject.name'],
+              },
+              {
+                path: ['$.type', '$.vc.type'],
+                filter: {
+                  type: 'array',
+                  contains: {
+                    const: 'BasicCredential',
+                  },
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
 
-    (pexService.presentationFrom as jest.Mock).mockResolvedValue({
-      presentation_submission: presentationSubmission,
-    });
+    const holderDID =
+      'did:key:z6MkkS7LbdxSqP8WM5GfsXiNwZC6Ve33aj83eEyzsFGphepp';
 
     const result = await getPresentationSubmision({
       credentials,
@@ -114,11 +169,16 @@ describe('getPresentationSubmision', () => {
       holderDID,
     });
 
-    expect(pexService.presentationFrom).toHaveBeenCalledWith({
-      presentationDefinition,
-      credentials,
-      holderDID,
+    expect(result).toStrictEqual({
+      id: expect.any(String),
+      definition_id: '94d240d2-b70f-412e-8331-1b610407cce6',
+      descriptor_map: [
+        {
+          id: 'OpenFinanceCredentialV2',
+          format: 'ldp_vc',
+          path: '$.verifiableCredential[0]',
+        },
+      ],
     });
-    expect(result).toEqual(presentationSubmission);
   });
 });

package/src/credentials/oidvc.ts

@@ -113,7 +113,7 @@ export async function getPresentationSubmision({
     holderDID,
   });
 
-  return presentation.presentation_submission;
+  return presentation?.presentation_submission;
 }
 
 pexService.evaluatePresentation;

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;

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;
 }