feat(core): linking of ipex flows to contacts

src/core/agent/agent.ts

@@ -170,7 +170,8 @@ class Agent {
  this.notificationStorage,
  this.identifierStorage,
  this.operationPendingStorage,
- this.connectionStorage
+ this.connectionStorage,
+ this.ipexMessageStorage
  );
  }
  return this.signifyNotificationService;

src/core/agent/records/ipexMessageStorage.test.ts

@@ -66,6 +66,23 @@ describe("ipexMessage Storage", () => {
  expect(storageService.save).toBeCalledWith(ipexMessageRecordA);
  });
 
+ test("Should find ipexMessage record by id", async () => {
+ storageService.findById.mockResolvedValue(ipexMessageRecordB);
+ const result = await ipexMessageStorage.getIpexMessageMetadata(
+ ipexMessageRecordB.connectionId
+ );
+ expect(result).toEqual(ipexMessageRecordB);
+ });
+
+ test("Should throw error if there is no matching record", async () => {
+ storageService.findById.mockResolvedValue(null);
+ await expect(
+ ipexMessageStorage.getIpexMessageMetadata("not-found-id")
+ ).rejects.toThrowError(
+ IpexMessageStorage.IPEX_MESSAGE_METADATA_RECORD_MISSING
+ );
+ });
+
  test("Should find ipexMessage record by connectionId", async () => {
  storageService.findAllByQuery.mockResolvedValue([
  ipexMessageRecordA,

src/core/agent/records/ipexMessageStorage.ts

@@ -15,6 +15,14 @@ class IpexMessageStorage {
  await this.storageService.save(record);
  }
 
+ async getIpexMessageMetadata(id: string): Promise<IpexMessageRecord> {
+ const metadata = await this.storageService.findById(id, IpexMessageRecord);
+ if (!metadata) {
+ throw new Error(IpexMessageStorage.IPEX_MESSAGE_METADATA_RECORD_MISSING);
+ }
+ return metadata;
+ }
+
  async getIpexMessageMetadataByConnectionId(
  connectionId: string
  ): Promise<IpexMessageRecord[]> {

src/core/agent/services/connectionService.test.ts

@@ -628,9 +628,10 @@ describe("Connection service of agent", () => {
  });
 
  test("Can get connection History by id", async () => {
+ jest.restoreAllMocks();
  const connectionId = "connectionId";
  const date1 = new Date("Sat Jul 27 2024 15:02:30 GMT+0700");
- const date2 = new Date("Sat Jul 27 2024 15:12:04 GMT+0700");
+ const date2 = new Date("Sat Jul 27 2024 15:45:04 GMT+0700");
  const date3 = new Date("Sat Jul 27 2024 15:30:34 GMT+0700");
  getIpexMessageMetadataByConnectionIdMock.mockResolvedValue([
  {
@@ -640,7 +641,7 @@ describe("Connection service of agent", () => {
  r: "/ipex/grant",
  e: {
  acdc: {
- d: "EN_tsGwSUI63SYoSiiN8qsysUT8bnka9gZEka8PG_oVQ",
+ d: "EN_tsGwSUI63SYoSiiN8qsysUT8bnka9gZEka8PG_oVK",
  },
  },
  },
@@ -690,13 +691,13 @@ describe("Connection service of agent", () => {
  );
  expect(histories).toEqual([
  {
- type: ConnectionHistoryType.CREDENTIAL_UPDATE,
- timestamp: date3.toISOString(),
+ type: ConnectionHistoryType.CREDENTIAL_REQUEST_PRESENT,
+ timestamp: date2.toISOString(),
  credentialType: "IIW 2024 Demo Day Attendee",
  },
  {
- type: ConnectionHistoryType.CREDENTIAL_REQUEST_PRESENT,
- timestamp: date2.toISOString(),
+ type: ConnectionHistoryType.CREDENTIAL_UPDATE,
+ timestamp: date3.toISOString(),
  credentialType: "IIW 2024 Demo Day Attendee",
  },
  {

src/core/agent/services/connectionService.ts

@@ -308,9 +308,8 @@ class ConnectionService extends AgentService {
  await this.ipexMessageStorage.getIpexMessageMetadataByConnectionId(
  connectionId
  );
-
  const requestMessages = linkedIpexMessages
- .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
+ .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
  .map((messageRecord) => {
  const { historyType, createdAt, credentialType } = messageRecord;
  return {
@@ -319,7 +318,7 @@ class ConnectionService extends AgentService {
  credentialType,
  };
  });
- return requestMessages.reverse();
+ return requestMessages;
  }
 
  // @TODO - foconnor: Contacts that are smid/rmids for multisigs will be synced too.

src/core/agent/services/ipexCommunicationService.test.ts

@@ -1,10 +1,10 @@
 import { EventService } from "./eventService";
 import { IpexCommunicationService } from "./ipexCommunicationService";
-import { CredentialStatus } from "./credentialService.types";
 import { Agent } from "../agent";
 import { IdentifierStorage } from "../records";
 import { ConfigurationService } from "../../configuration";
 import { OperationPendingRecordType } from "../records/operationPendingRecord.type";
+import { ConnectionHistoryType } from "./connection.types";
 
 const notificationStorage = jest.mocked({
  open: jest.fn(),
@@ -208,6 +208,49 @@ const ipexCommunicationService = new IpexCommunicationService(
  operationPendingStorage as any
 );
 
+const grantIpexMessageMock = {
+ exn: {
+ v: "KERI10JSON000516_",
+ t: "exn",
+ d: "EJ1jbI8vTFCEloTfSsZkBpV0bUJnhGVyak5q-5IFIglL",
+ i: "EC9bQGHShmp2Juayqp0C5XcheBiHyc1p54pZ_Op-B95x",
+ p: "",
+ dt: "2024-07-30T04:19:55.801000+00:00",
+ r: "/ipex/grant",
+ q: {},
+ a: {
+ m: "",
+ i: "EE-gjeEni5eCdpFlBtG7s4wkv7LJ0JmWplCS4DNQwW2G",
+ },
+ e: {
+ acdc: {
+ d: "EEqfWy-6jx_FG0RNuNxZBh_jq6Lq1OPuvX5m3v1Bzxdn",
+ i: "EC9bQGHShmp2Juayqp0C5XcheBiHyc1p54pZ_Op-B95x",
+ s: "EBIFDhtSE0cM4nbTnaMqiV1vUIlcnbsqBMeVMmeGmXOu",
+ a: {
+ d: "ELHCh_X2aw7C-aYesOM4La23a5lsoNuJDuCsJuxwO2nq",
+ i: "EE-gjeEni5eCdpFlBtG7s4wkv7LJ0JmWplCS4DNQwW2G",
+ dt: "2024-07-30T04:19:55.348000+00:00",
+ attendeeName: "ccc",
+ },
+ },
+ iss: {
+ t: "iss",
+ d: "EHStOgwJku_Ln-YN2ohgWUH-CI07SyJnFppSbF8kG4PO",
+ i: "EEqfWy-6jx_FG0RNuNxZBh_jq6Lq1OPuvX5m3v1Bzxdn",
+ s: "0",
+ dt: "2024-07-30T04:19:55.348000+00:00",
+ },
+ d: "EKBPPnWxYw2I5CtQSyhyn5VUdSTJ61qF_-h-NwmFRkIF",
+ },
+ },
+ pathed: {
+ acdc: "-IABEEqfWy-6jx_FG0RNuNxZBh_jq6Lq1OPuvX5m3v1Bzxdn0AAAAAAAAAAAAAAAAAAAAAAAEHStOgwJku_Ln-YN2ohgWUH-CI07SyJnFppSbF8kG4PO",
+ iss: "-VAS-GAB0AAAAAAAAAAAAAAAAAAAAAAAEEO0xKzC8FOAXV-JgFZGgb0aIT2A3cPXPt9_0l_qcGM9",
+ anc: "-AABAACBlQqbI_qNpKYkzIog6tauSgt0XufBvGtrumfbnhSInFjSwnaIqZi353QT-c1W_gE9KIz3rgX5QNNWLcqA7bcM",
+ },
+};
+
 describe("Ipex communication service of agent", () => {
  beforeAll(async () => {
  await new ConfigurationService().start();
@@ -569,6 +612,49 @@ describe("Ipex communication service of agent", () => {
  });
  });
 
+ test("can create linked ipex message record", async () => {
+ Agent.agent.getKeriaOnlineStatus = jest.fn().mockReturnValueOnce(true);
+ const schemaMock = { title: "title" };
+ schemaGetMock.mockResolvedValueOnce(schemaMock);
+ await ipexCommunicationService.createLinkedIpexMessageRecord(
+ grantIpexMessageMock,
+ ConnectionHistoryType.CREDENTIAL_ISSUANCE
+ );
+ expect(ipexMessageRecordStorage.createIpexMessageRecord).toBeCalledWith({
+ id: grantIpexMessageMock.exn.d,
+ credentialType: schemaMock.title,
+ content: grantIpexMessageMock,
+ connectionId: grantIpexMessageMock.exn.i,
+ historyType: ConnectionHistoryType.CREDENTIAL_ISSUANCE,
+ });
+
+ schemaGetMock.mockRejectedValueOnce(
+ new Error("request - 404 - SignifyClient message")
+ );
+ await ipexCommunicationService.createLinkedIpexMessageRecord(
+ grantIpexMessageMock,
+ ConnectionHistoryType.CREDENTIAL_ISSUANCE
+ );
+ expect(ipexMessageRecordStorage.createIpexMessageRecord).toBeCalledWith({
+ id: grantIpexMessageMock.exn.d,
+ credentialType: undefined,
+ content: grantIpexMessageMock,
+ connectionId: grantIpexMessageMock.exn.i,
+ historyType: ConnectionHistoryType.CREDENTIAL_ISSUANCE,
+ });
+ });
+
+ test("Should throw error if schemas.get has an unexpected error", async () => {
+ Agent.agent.getKeriaOnlineStatus = jest.fn().mockReturnValueOnce(true);
+ schemaGetMock.mockRejectedValueOnce(new Error("Unknown error"));
+ await expect(
+ ipexCommunicationService.createLinkedIpexMessageRecord(
+ grantIpexMessageMock,
+ ConnectionHistoryType.CREDENTIAL_REQUEST_PRESENT
+ )
+ ).rejects.toThrowError(new Error("Unknown error"));
+ });
+
  test("cannot get matching credential for apply if cannot get the schema", async () => {
  Agent.agent.getKeriaOnlineStatus = jest.fn().mockReturnValueOnce(true);
  const notiId = "notiId";

src/core/agent/services/ipexCommunicationService.ts

@@ -344,16 +344,43 @@ class IpexCommunicationService extends AgentService {
  }
 
  async createLinkedIpexMessageRecord(
- credentialType: string,
- connectionId: string,
  message: IpexMessage,
  historyType: ConnectionHistoryType
  ): Promise<void> {
+ const schemaSaid = message.exn.e.acdc.s;
+ const allSchemaSaids = Object.keys(message.exn.e.acdc?.e || {}).map(
+ // Chained schemas
+ (key) => message.exn.e.acdc.e?.[key]?.s
+ );
+ allSchemaSaids.push(schemaSaid);
+ await Promise.all(
+ allSchemaSaids.map(
+ async (schemaSaid) =>
+ await Agent.agent.connections.resolveOobi(
+ `${ConfigurationService.env.keri.credentials.testServer.urlInt}/oobi/${schemaSaid}`,
+ true
+ )
+ )
+ );
+
+ const schema = await this.props.signifyClient
+ .schemas()
+ .get(schemaSaid)
+ .catch((error) => {
+ const errorStack = (error as Error).stack as string;
+ const status = errorStack.split("-")[1];
+ if (/404/gi.test(status) && /SignifyClient/gi.test(errorStack)) {
+ return undefined;
+ } else {
+ throw error;
+ }
+ });
+
  await this.ipexMessageStorage.createIpexMessageRecord({
- id: uuidv4(),
- credentialType,
+ id: message.exn.d,
+ credentialType: schema?.title,
  content: message,
- connectionId,
+ connectionId: message.exn.i,
  historyType,
  });
  }