@docknetwork/wallet-sdk-core 0.4.19 → 1.4.0

package/src/credential-provider.ts

@@ -1,10 +1,13 @@
 import {credentialServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/credential';
 import {IWallet} from './types';
 import assert from 'assert';
-import { dockService } from '@docknetwork/wallet-sdk-wasm/src/services/dock';
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
+import {acquireOpenIDCredentialFromURI} from './credentials/oidvc';
+import {IDIDProvider} from './did-provider';
 
 export type Credential = any;
 
+
 export interface ICredentialProvider {
   getCredentials(type?: string): Credential[];
   getById(id: string): Credential;
@@ -12,8 +15,15 @@ export interface ICredentialProvider {
   isBBSPlusCredential(credential: any): boolean;
   isValid(credential: any, forceFetch?: boolean): Promise<boolean>;
   addCredential(credential: any): Promise<Credential>;
-  syncCredentialStatus(params: SyncCredentialStatusParams): Promise<CredentialStatusDocument[]>;
-  getCredentialStatus(credential: Credential): Promise<{status: string, error?: string}>;
+  importCredentialFromURI(
+    params: importCredentialFromUriParams,
+  ): Promise<Credential>;
+  syncCredentialStatus(
+    params: SyncCredentialStatusParams,
+  ): Promise<CredentialStatusDocument[]>;
+  getCredentialStatus(
+    credential: Credential,
+  ): Promise<{status: string; error?: string}>;
 }
 
 export function isBBSPlusCredential(credential) {
@@ -27,8 +37,38 @@ export function isBBSPlusCredential(credential) {
   );
 }
 
+type importCredentialFromUriParams = {
+  uri: string;
+  didProvider: IDIDProvider;
+  getAuthCode?: (authorizationURL: string) => Promise<string>;
+};
+
+export async function importCredentialFromURI({
+  uri,
+  wallet,
+  didProvider,
+  getAuthCode,
+}: importCredentialFromUriParams & {
+  wallet: IWallet;
+}) {
+  // TODO: unify the impl with the existing import credential flow
+  // if the URI is an OpenID credential offer, use the OpenID flow
+  // if the URI is a dock credential, then get user password and import that
+  // we can add support for other types of credentials later
+  const credential = await acquireOpenIDCredentialFromURI({
+    didProvider,
+    uri,
+    getAuthCode,
+  });
+
+  await addCredential({wallet, credential});
+}
+
 export function isCredentialExpired(credential) {
-  return !!credential.expirationDate && new Date(credential.expirationDate) < new Date();
+  return (
+    !!credential.expirationDate &&
+    new Date(credential.expirationDate) < new Date()
+  );
 }
 
 /**
@@ -52,10 +92,12 @@ export async function isValid({
       };
     }
 
-    const membershipWitness = credential[ACUMM_WITNESS_PROP_KEY] || await getMembershipWitness({
-      credentialId: credential.id,
-      wallet,
-    });
+    const membershipWitness =
+      credential[ACUMM_WITNESS_PROP_KEY] ||
+      (await getMembershipWitness({
+        credentialId: credential.id,
+        wallet,
+      }));
 
     delete credential[ACUMM_WITNESS_PROP_KEY];
 
@@ -64,10 +106,13 @@ export async function isValid({
       membershipWitness,
     });
 
-    const { verified, error }  = verificationResult;
-  
+    const {verified, error} = verificationResult;
+
     if (!verified) {
-      if (typeof error === 'string' && error.toLowerCase().includes('revocation')) {
+      if (
+        typeof error === 'string' &&
+        error.toLowerCase().includes('revocation')
+      ) {
         return {
           status: CredentialStatus.Revoked,
           error,
@@ -113,7 +158,7 @@ export async function addCredential({wallet, credential}) {
     });
   }
 
-  syncCredentialStatus({ wallet, credentialIds: [credential.id] });
+  syncCredentialStatus({wallet, credentialIds: [credential.id]});
 
   return response;
 }
@@ -123,7 +168,6 @@ async function getMembershipWitness({credentialId, wallet}) {
   return document?.value;
 }
 
-
 export const CredentialStatus = {
   Invalid: 'invalid',
   Expired: 'expired',
@@ -134,28 +178,32 @@ export const CredentialStatus = {
 
 type SyncCredentialStatusParams = {
   // Optional credential IDs to sync
-  credentialIds?: string[],
+  credentialIds?: string[];
   // Skip the cache and re-fetch from the chain
-  forceFetch?: boolean,
+  forceFetch?: boolean;
 };
 
 type CredentialStatusDocument = {
   id: string;
   status: string;
   error: string;
-}
+};
 
 /**
  * Fetch credential status from the chain and update the wallet
  * Store a new document <credentialId>#status in the wallet
  * Returns a list of CredentialStatusDocument
- * 
+ *
  * @param param0
  * @returns CredentialStatusDocument[]
  */
-async function syncCredentialStatus({ wallet, credentialIds, forceFetch }: SyncCredentialStatusParams & {
+async function syncCredentialStatus({
+  wallet,
+  credentialIds,
+  forceFetch,
+}: SyncCredentialStatusParams & {
   wallet: IWallet;
-} ): Promise<CredentialStatusDocument[]> {
+}): Promise<CredentialStatusDocument[]> {
   let credentials;
 
   if (credentialIds && credentialIds.length) {
@@ -167,7 +215,7 @@ async function syncCredentialStatus({ wallet, credentialIds, forceFetch }: SyncC
   let statusDocs = [];
 
   let isApiConnected;
-  
+
   for (const credential of credentials) {
     let shouldFetch = !!forceFetch;
     let statusDoc = await wallet.getDocumentById(`${credential.id}#status`);
@@ -214,10 +262,10 @@ async function syncCredentialStatus({ wallet, credentialIds, forceFetch }: SyncC
     if (!isApiConnected) {
       await dockService.ensureDockReady();
       isApiConnected = true;
-    }    
+    }
 
-    const result = await isValid({ credential, wallet });
-    statusDoc.status = result?.status
+    const result = await isValid({credential, wallet});
+    statusDoc.status = result?.status;
     statusDoc.error = result?.error;
     statusDoc.updatedAt = new Date().toISOString();
 
@@ -237,6 +285,11 @@ export function createCredentialProvider({
   }
 
   return {
+    importCredentialFromURI: async (params: importCredentialFromUriParams) =>
+      importCredentialFromURI({
+        ...params,
+        wallet,
+      }),
     getCredentials,
     getMembershipWitness: async (credentialId: string) =>
       getMembershipWitness({credentialId, wallet}),
@@ -261,10 +314,10 @@ export function createCredentialProvider({
       return {
         status: statusDoc?.status || CredentialStatus.Pending,
         error: statusDoc?.error,
-      }
+      };
     },
     syncCredentialStatus: async (props: SyncCredentialStatusParams) => {
-      return syncCredentialStatus({ wallet, ...props });
+      return syncCredentialStatus({wallet, ...props});
     },
     addCredential: credential => addCredential({wallet, credential}),
     // TODO: move import credential from json or URL to this provider

package/src/credentials/oidvc.test.ts

@@ -0,0 +1,124 @@
+import {
+  acquireOpenIDCredentialFromURI,
+  getAuthURL,
+  decodeRequestJWT,
+  getPresentationSubmision,
+} from './oidvc'; // replace with your actual file path
+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 = {
+    getDIDKeyPairs: jest.fn(),
+  };
+
+  const uri = 'https://example.com/credential';
+
+  beforeEach(() => {
+    didProvider.getDIDKeyPairs.mockResolvedValue([{id: 'did:example:123'}]);
+    (credentialServiceRPC.acquireOIDCredential as jest.Mock).mockResolvedValue({
+      credential: 'fake-credential',
+    });
+  });
+
+  it('should acquire OID credential without authorization URL', async () => {
+    const response = await acquireOpenIDCredentialFromURI({didProvider, uri});
+    expect(didProvider.getDIDKeyPairs).toHaveBeenCalled();
+    expect(credentialServiceRPC.acquireOIDCredential).toHaveBeenCalledWith({
+      uri,
+      holderKeyDocument: {id: 'did:example:123'},
+    });
+    expect(response).toBe('credential');
+  });
+
+  it('should acquire OID credential with authorization URL', async () => {
+    const getAuthCode = jest.fn().mockResolvedValue('auth-code');
+    (credentialServiceRPC.acquireOIDCredential as jest.Mock).mockResolvedValueOnce({
+      authorizationURL: 'https://example.com/auth',
+    });
+
+    const response = await acquireOpenIDCredentialFromURI({
+      didProvider,
+      uri,
+      getAuthCode,
+    });
+    expect(getAuthCode).toHaveBeenCalledWith('https://example.com/auth');
+    expect(credentialServiceRPC.acquireOIDCredential).toHaveBeenCalledWith({
+      uri,
+      holderKeyDocument: {id: 'did:example:123'},
+      authorizationCode: 'auth-code',
+    });
+    expect(response).toBe('credential');
+  });
+});
+
+describe('getAuthURL', () => {
+  it('should generate an auth URL', async () => {
+    const uri = 'https://example.com?client_id=fake-client';
+    const metadata = {
+      authorizationServerMetadata: {
+        request_object_signing_alg_values_supported: ['RS256'],
+      },
+      authorization_endpoint: 'https://auth.example.com/authorize',
+    };
+    (MetadataClient.retrieveAllMetadata as jest.Mock).mockResolvedValue(metadata);
+
+    const result = await getAuthURL(uri);
+    expect(MetadataClient.retrieveAllMetadata).toHaveBeenCalledWith(
+      'fake-client',
+    );
+    expect(result).toContain('https://auth.example.com/authorize?');
+    expect(result).toContain('client_id=dock-wallet');
+    expect(result).toContain('redirect_uri=dockwallet://vp');
+  });
+});
+
+describe('decodeRequestJWT', () => {
+  it('should decode JWT from the request URI', async () => {
+    const uri = 'https://example.com?request_uri=https://example.com/jwt';
+    const jwt = 'some-jwt';
+    const decodedJWT = {sub: '1234567890', name: 'Testing', admin: true};
+    (axios.get as jest.Mock).mockResolvedValue({data: jwt});
+    (jwtDecode as jest.Mock).mockReturnValue(decodedJWT);
+
+    const result = await decodeRequestJWT(uri);
+    expect(axios.get).toHaveBeenCalledWith('https://example.com/jwt');
+    expect(jwtDecode).toHaveBeenCalledWith(jwt);
+    expect(result).toEqual(decodedJWT);
+  });
+});
+
+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'};
+
+    (pexService.presentationFrom as jest.Mock).mockResolvedValue({
+      presentation_submission: presentationSubmission,
+    });
+
+    const result = await getPresentationSubmision({
+      credentials,
+      presentationDefinition,
+      holderDID,
+    });
+
+    expect(pexService.presentationFrom).toHaveBeenCalledWith({
+      presentationDefinition,
+      credentials,
+      holderDID,
+    });
+    expect(result).toEqual(presentationSubmission);
+  });
+});

package/src/credentials/oidvc.ts

@@ -0,0 +1,115 @@
+import {IWallet} from '../types';
+import {IDIDProvider} from '../did-provider';
+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';
+import {WellKnownEndpoints} from '@sphereon/oid4vci-common';
+
+export async function acquireOpenIDCredentialFromURI({
+  didProvider,
+  uri,
+  getAuthCode,
+}: {
+  didProvider: IDIDProvider;
+  uri: string;
+  getAuthCode?: (authorizationURL: string) => Promise<string>;
+}) {
+  const [holderKeyDocument] = await didProvider.getDIDKeyPairs();
+
+  let response = await credentialServiceRPC.acquireOIDCredential({
+    uri,
+    holderKeyDocument,
+  });
+
+  if (response.authorizationURL) {
+    const authorizationCode = await getAuthCode(response.authorizationURL);
+    response = await credentialServiceRPC.acquireOIDCredential({
+      uri,
+      holderKeyDocument,
+      authorizationCode,
+    });
+  }
+
+  return response.credential;
+}
+
+export async function getAuthURL(
+  uri: string,
+  walletClientId: string = 'dock-wallet',
+  requestedRedirectURI: string = 'dockwallet://vp',
+) {
+  function buildOID4VPRequestURL(params, prefix = 'dockwallet://') {
+    return `${prefix}?${Object.keys(params)
+      .map(
+        key =>
+          `${encodeURIComponent(key)}=${encodeURIComponent(
+            typeof params[key] === 'object'
+              ? JSON.stringify(params[key])
+              : params[key],
+          )}`,
+      )
+      .join('&')}`;
+  }
+
+  const searchParams = new URL(uri).searchParams;
+  const params = new URLSearchParams(searchParams);
+  const clientId = params.get('client_id');
+  // We need to investigate why MetadataClient.retrieveAllMetadata(clientId); is not working on android
+  // Follow up bug ticket: https://dock-team.atlassian.net/browse/DCKM-600
+  const metadataURI = `${clientId}${WellKnownEndpoints.OPENID_CONFIGURATION}`;
+  const {data: metadata} = await axios.get(metadataURI);
+
+  const requestedAlg =
+    metadata?.authorizationServerMetadata
+      ?.request_object_signing_alg_values_supported[0];
+  const requestParams = {
+    scope: 'openid vp_token',
+    redirect_uri: requestedRedirectURI,
+    client_metadata:
+      requestedAlg && requestedAlg !== 'EdDSA'
+        ? JSON.stringify({
+            vp_formats_supported: {
+              vc_json: {
+                alg_values_supported: [requestedAlg],
+              },
+            },
+          })
+        : ['EdDSA'],
+  };
+
+  return buildOID4VPRequestURL(
+    {
+      ...requestParams,
+      client_id: walletClientId,
+    },
+    metadata.authorization_endpoint,
+  );
+}
+
+export async function decodeRequestJWT(uri: string) {
+  const searchParams = new URL(uri).searchParams;
+  const params = new URLSearchParams(searchParams);
+  const requestUri = params.get('request_uri');
+  const jwt = await axios.get(requestUri).then(res => res.data);
+  const decoded = jwtDecode(jwt);
+
+  return decoded;
+}
+
+export async function getPresentationSubmision({
+  credentials,
+  presentationDefinition,
+  holderDID,
+}) {
+  const presentation = await pexService.presentationFrom({
+    presentationDefinition,
+    credentials,
+    holderDID,
+  });
+
+  return presentation.presentation_submission;
+}
+
+pexService.evaluatePresentation;

package/src/did-provider.test.ts

@@ -1,8 +1,14 @@
 import {IWallet} from './types';
 import {createWallet} from './wallet';
-import {createDIDock, createDIDKey, createDIDProvider, IDIDProvider} from './did-provider';
+import {
+  createDIDock,
+  createDIDKey,
+  createDIDProvider,
+  IDIDProvider,
+} from './did-provider';
 import {createAccountProvider} from './account-provider';
 import {didServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/dids';
+import {createDataStore} from '@docknetwork/wallet-sdk-data-store-typeorm/src';
 
 describe('DID Provider', () => {
   let wallet: IWallet;
@@ -49,7 +55,9 @@ describe('DID Provider', () => {
 
   beforeEach(async () => {
     wallet = await createWallet({
-      databasePath: ':memory:',
+      dataStore: await createDataStore({
+        databasePath: ':memory:',
+      }),
     });
     accountProvider = createAccountProvider({wallet});
     didProvider = createDIDProvider({wallet});
@@ -149,18 +157,19 @@ describe('DID Provider', () => {
 
   describe('create DID Key', () => {
     it('expect to create a DID Key', async () => {
-
       jest.spyOn(didServiceRPC, 'generateKeyDoc').mockResolvedValueOnce({
         id: 'did:key:abcde#key-1',
         type: 'KeyDocument',
       });
 
-      jest.spyOn(didServiceRPC, 'keypairToDIDKeyDocument').mockResolvedValueOnce({
-        didDocument: {
-          id: 'did:key:abcde#key-2',
-          type: 'DidDocument',
-        }
-      });
+      jest
+        .spyOn(didServiceRPC, 'keypairToDIDKeyDocument')
+        .mockResolvedValueOnce({
+          didDocument: {
+            id: 'did:key:abcde#key-2',
+            type: 'DidDocument',
+          },
+        });
 
       jest.spyOn(didServiceRPC, 'getDIDResolution').mockResolvedValueOnce({
         id: new Date().getTime().toString(),
@@ -185,10 +194,9 @@ describe('DID Provider', () => {
       expect(didDocument.length).toBe(2);
     });
     it('expect to assert parameters', async () => {
-
       await expect(
         didProvider.createDIDKey({
-          name: ''
+          name: '',
         }),
       ).rejects.toThrowError('name is required');
 

package/src/ecosystem-tools.ts

@@ -1,35 +1,60 @@
 import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
 import {trustRegistryService} from '@docknetwork/wallet-sdk-wasm/src/services/trust-registry';
+import assert from 'assert';
+import axios from 'axios';
+
+
+function getApiURL(networkId) {
+  return networkId === 'mainnet' ? 'https://api.dock.io' : 'https://api-testnet.dock.io';
+}
 
 export async function getEcosystems({
   issuerDID,
   verifierDID,
   schemaId,
+  networkId,
 }: {
+  networkId: string;
   issuerDID?: string;
   verifierDID?: string;
   schemaId?: string;
 }) {
-  await dockService.ensureDockReady();
-
+  assert(!!networkId, 'networkId is required');
+  
   try {
-    return await trustRegistryService.getTrustRegistries({issuerDID, verifierDID, schemaId});
+    // TODO: Use the SDK to fetch ecosystems when it's available
+    const {data} = await axios.post(`${getApiURL(networkId)}/trust-registries/query`,{
+      issuerDID,
+      verifierDID,
+      schemaId,
+    })
+
+    const registries = {}
+
+    data.forEach((registry) => {
+      registries[registry.id] = registry;
+    });
+
+    return registries;
   } catch (error) {
     console.log('error', error);
     return [];
   }
 }
 
-export async function getVerifiers({trustRegistryId, issuerDID, schemaId}) {
-  await dockService.ensureDockReady();
+export async function getVerifiers({trustRegistryId, issuerDID, schemaId, networkId}: {
+  trustRegistryId: string;
+  issuerDID?: string;
+  schemaId?: string;
+  networkId: string;
+}) {
+  assert(!!networkId, 'networkId is required');
+  assert(!!trustRegistryId, 'trustRegistryId is required');
 
   try {
-    const verifiers = await trustRegistryService.getTrustRegistryVerifiers({
-      schemaId,
-      issuerDID: issuerDID,
-      trustRegistryId,
-    });
-    return verifiers;
+    // TODO: Use the SDK to fetch verifiers when it's available
+    const { data } = await axios.get(`${getApiURL(networkId)}/trust-registries/${trustRegistryId}/verifiers?schemaId=${encodeURIComponent(schemaId)}&issuerDID=${issuerDID}`);
+    return data;
   } catch (error) {
     console.log('error', error);
     return [];

package/src/fixtures/biometrics-credential-bbs-revocation.json

@@ -13,7 +13,7 @@
 		"revocationCheck": "membership",
 		"revocationId": "9"
 	},
-	"id": "https://creds-staging.dock.io/83e0641f88e7ae5b18e8ae4a9ca616d23df8370501375269db9e21d857d6ce55",
+	"id": "https://creds-example.dock.io/83e0641f88e7ae5b18e8ae4a9ca616d23df8370501375269db9e21d857d6ce55",
 	"type": [
 		"VerifiableCredential",
 		"BiometricsCredential"
@@ -59,4 +59,4 @@
 		"proofValue": "zY4LVnbLxwjnk2En988EVHvqsysjELpAcD3A72832JUHS3DreVjv2P9fN6J4CyWo9qC1qiiqBWkNzKP73ZF6tdSzTLzYgByqsXKDxLoyW7LqU2byPjAhHx2GKXTkKVqB3P3WtwxMGCcXR1tQqNhz91do5h"
 	},
 	"$$accum__witness$$": "0xb2249e8faadb33015bfc2dbe74bbd916f5efacff92d0e1235827e4e1b23438d9c45e427376cbcc164ab41c3bd0ace3c8"
-}
+}

package/src/fixtures/iiw-credential.json

@@ -12,7 +12,7 @@
     },
     "https://ld.dock.io/credentials/prettyvc"
   ],
-  "id": "https://creds-staging.dock.io/d02cc3892ae688dae923dd470443b1ee41a046206a6ae1775e4dbff25abccc6f",
+  "id": "https://creds-example.dock.io/d02cc3892ae688dae923dd470443b1ee41a046206a6ae1775e4dbff25abccc6f",
   "type": [
     "VerifiableCredential",
     "IIW",

package/src/fixtures/iiw-template.json

@@ -1,12 +1,12 @@
 {
-  "qr": "https://creds-staging.dock.io/proof/f6b0c6a7-ae27-4044-80a3-07f5af6e61c8",
+  "qr": "https://creds-example.dock.io/proof/f6b0c6a7-ae27-4044-80a3-07f5af6e61c8",
   "id": "f6b0c6a7-ae27-4044-80a3-07f5af6e61c8",
   "name": "boolean",
   "nonce": "e2cb13292035d73e97543c8f463c3f06",
   "created": "2023-08-17T17:38:38.276Z",
   "updated": "2023-08-17T17:38:38.276Z",
   "verified": false,
-  "response_url": "https://api-staging.dock.io/proof-requests/f6b0c6a7-ae27-4044-80a3-07f5af6e61c8/send-presentation",
+  "response_url": "${TESTING_API_URL}/proof-requests/f6b0c6a7-ae27-4044-80a3-07f5af6e61c8/send-presentation",
   "request": {
     "id": "f6b0c6a7-ae27-4044-80a3-07f5af6e61c8",
     "input_descriptors": [

package/src/helpers.ts

@@ -59,3 +59,13 @@ export function getJSON(jsonOrURL: string | any) {
 
   throw new Error(`Invalid data ${jsonOrURL}`);
 }
+
+export function replaceResponseURL(templateRequest){
+  assert(process.env.TESTING_API_URL, "Please configure the TESTING_API_URL env var.");
+
+  if (templateRequest?.response_url){
+    templateRequest.response_url = templateRequest.response_url.replace("${TESTING_API_URL}", process.env.TESTING_API_URL);
+  }
+
+  return templateRequest;
+}

package/src/message-provider.test.ts

@@ -1,3 +1,4 @@
+import { createDataStore } from '@docknetwork/wallet-sdk-data-store-typeorm/src';
 import {IDIDProvider, createDIDProvider} from './did-provider';
 import {IMessageProvider, createMessageProvider} from './message-provider';
 import {IWallet, createWallet} from './wallet';
@@ -25,17 +26,20 @@ describe('MessageProvider', () => {
   beforeEach(async () => {
     relayService = {
       sendMessage: jest.fn(),
+      ackMessages: jest.fn(),
       getMessages: jest.fn().mockResolvedValue(didCommMessages),
       resolveDidcommMessage: jest.fn().mockImplementation(({ message }) => message),
     };
 
     wallet = await createWallet({
-      databasePath: ':memory:',
+      dataStore: await createDataStore({
+        databasePath: ':memory:',
+      })
     });
     didProvider = createDIDProvider({
       wallet,
     });
-    didProvider.getDIDKeyPairs = jest.fn().mockResolvedValue([{controller: "someDid"}])
+    didProvider.getDIDKeyPairs = jest.fn().mockResolvedValue([{controller: "did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT"}])
     messageProvider = createMessageProvider({
       wallet,
       didProvider,
@@ -51,6 +55,8 @@ describe('MessageProvider', () => {
       const walletMessage = await wallet.getDocumentById(message._id);
       expect(walletMessage.encryptedMessage).toEqual(message);
     }
+
+    expect(relayService.ackMessages).toBeCalledWith({did: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT', messageIds: didCommMessages.map(m => m._id)});
   });
 
   it('should decrypt encrypted messages in the wallet', async () => {
@@ -75,7 +81,7 @@ describe('MessageProvider', () => {
     
     await expect(
       messageProvider.sendMessage({
-        did: 'someDid',
+        did: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT',
         message: 'someMessage',
         recipientDid: 'recipientDid',
       })