feat: single-sig IPEX apply, offer, agree

examples/integration-scripts/credentials.test.ts

@@ -51,6 +51,10 @@
 let verifierAid: Aid;
 let legalEntityAid: Aid;
 
+let applySaid: string;
+let offerSaid: string;
+let agreeSaid: string;
+
 beforeAll(async () => {
     [issuerClient, holderClient, verifierClient, legalEntityClient] =
         await getOrCreateClients(4);
@@ -125,7 +129,7 @@
             .rename(issuerAid.name, registryName, updatedRegistryName);
 
         registries = await issuerClient.registries().list(issuerAid.name);
         let updateRegistry: { name: string; regk: string } = registries[0];
         assert.equal(registries.length, 1);
         assert.equal(updateRegistry.name, updatedRegistryName);
 
@@ -243,7 +247,7 @@
             datetime: dt,
         });
 
         let op = await issuerClient
             .ipex()
             .submitGrant(issuerAid.name, grant, gsigs, gend, [
                 holderAid.prefix,
@@ -266,7 +270,7 @@
                 grantNotification.a.d!,
                 createTimestamp()
             );
         let op = await holderClient
             .ipex()
             .submitAdmit(holderAid.name, admit, sigs, aend, [issuerAid.prefix]);
         await waitOperation(holderClient, op);
@@ -296,7 +300,107 @@
         assert(holderCredential.atc !== undefined);
     });
 
-    await step('holder IPEX present', async () => {
+    await step('verifier IPEX apply', async () => {
+        const [apply, sigs, _] = await verifierClient.ipex().apply({
+            senderName: verifierAid.name,
+            schema: QVI_SCHEMA_SAID,
+            attributes: { LEI: '5493001KJTIIGC8Y1R17' },
+            recipient: holderAid.prefix,
+            datetime: createTimestamp(),
+        });
+
+        const op = await verifierClient
+            .ipex()
+            .submitApply(verifierAid.name, apply, sigs, [holderAid.prefix]);
+        await waitOperation(verifierClient, op);
+    });
+
+    await step('holder IPEX apply receive and offer', async () => {
+        const holderNotifications = await waitForNotifications(
+            holderClient,
+            '/exn/ipex/apply'
+        );
+
+        const holderApplyNote = holderNotifications[0];
+        assert(holderApplyNote.a.d);
+
+        const apply = await holderClient.exchanges().get(holderApplyNote.a.d);
+        applySaid = apply.exn.d;
+
+        let filter: { [x: string]: any } = { '-s': apply.exn.a.s };
+        for (const key in apply.exn.a.a) {
+            filter[`-a-${key}`] = apply.exn.a.a[key];
+        }
+
+        const matchingCreds = await holderClient.credentials().list({ filter });
+        expect(matchingCreds).toHaveLength(1);
+
+        await markAndRemoveNotification(holderClient, holderNotifications[0]);
+
+        const [offer, sigs, end] = await holderClient.ipex().offer({
+            senderName: holderAid.name,
+            recipient: verifierAid.prefix,
+            acdc: new Serder(matchingCreds[0].sad),
+            apply: applySaid,
+            datetime: createTimestamp(),
+        });
+
+        const op = await holderClient
+            .ipex()
+            .submitOffer(holderAid.name, offer, sigs, end, [
+                verifierAid.prefix,
+            ]);
+        await waitOperation(holderClient, op);
+    });
+
+    await step('verifier receive offer and agree', async () => {
+        const verifierNotifications = await waitForNotifications(
+            verifierClient,
+            '/exn/ipex/offer'
+        );
+
+        const verifierOfferNote = verifierNotifications[0];
+        assert(verifierOfferNote.a.d);
+
+        const offer = await verifierClient
+            .exchanges()
+            .get(verifierOfferNote.a.d);
+        offerSaid = offer.exn.d;
+
+        expect(offer.exn.p).toBe(applySaid);
+        expect(offer.exn.e.acdc.a.LEI).toBe('5493001KJTIIGC8Y1R17');
+
+        await markAndRemoveNotification(verifierClient, verifierOfferNote);
+
+        const [agree, sigs, _] = await verifierClient.ipex().agree({
+            senderName: verifierAid.name,
+            recipient: holderAid.prefix,
+            offer: offerSaid,
+            datetime: createTimestamp(),
+        });
+
+        const op = await verifierClient
+            .ipex()
+            .submitAgree(verifierAid.name, agree, sigs, [holderAid.prefix]);
+        await waitOperation(verifierClient, op);
+    });
+
+    await step('holder IPEX receive agree and grant/present', async () => {
+        const holderNotifications = await waitForNotifications(
+            holderClient,
+            '/exn/ipex/agree'
+        );
+
+        const holderAgreeNote = holderNotifications[0];
+        assert(holderAgreeNote.a.d);
+
+        const agree = await holderClient.exchanges().get(holderAgreeNote.a.d);
+        agreeSaid = agree.exn.d;
+
+        expect(agree.exn.p).toBe(offerSaid);
+
+        await markAndRemoveNotification(holderClient, holderAgreeNote);
+
         const holderCredential = await holderClient
             .credentials()
             .get(qviCredentialId);
@@ -310,10 +414,11 @@
             acdcAttachment: holderCredential.atc,
             ancAttachment: holderCredential.ancatc,
             issAttachment: holderCredential.issAtc,
+            agree: agreeSaid,
             datetime: createTimestamp(),
         });
 
         let op = await holderClient
             .ipex()
             .submitGrant(holderAid.name, grant2, gsigs2, gend2, [
                 verifierAid.prefix,
@@ -328,6 +433,10 @@
         );
 
         const verifierGrantNote = verifierNotifications[0];
+        assert(verifierGrantNote.a.d);
+
+        const grant = await holderClient.exchanges().get(verifierGrantNote.a.d);
+        expect(grant.exn.p).toBe(agreeSaid);
 
         const [admit3, sigs3, aend3] = await verifierClient
             .ipex()
@@ -361,6 +470,7 @@
             holderClient,
             '/exn/ipex/admit'
         );
+
         await markAndRemoveNotification(holderClient, holderNotifications[0]);
     });
 

src/keri/app/credentialing.ts

@@ -98,6 +98,85 @@ export interface RevokeCredentialResult {
     op: Operation;
 }
 
+export interface IpexApplyArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+
+    /**
+     * Message to send
+     */
+    message?: string;
+
+    /**
+     * SAID of schema to apply for
+     */
+    schema: string;
+
+    /**
+     * Optional attributes for selective disclosure
+     */
+    attributes?: Record<string, unknown>;
+    datetime?: string;
+}
+
+export interface IpexOfferArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+
+    /**
+     * Message to send
+     */
+    message?: string;
+
+    /**
+     * ACDC to offer
+     */
+    acdc: Serder;
+
+    /**
+     * Optional qb64 SAID of apply message this offer is responding to
+     */
+    apply?: string;
+    datetime?: string;
+}
+
+export interface IpexAgreeArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+
+    /**
+     * Message to send
+     */
+    message?: string;
+
+    /**
+     * qb64 SAID of offer message this agree is responding to
+     */
+    offer: string;
+    datetime?: string;
+}
+
 export interface IpexGrantArgs {
     /**
      * Alias for the IPEX sender AID
@@ -731,6 +810,139 @@ export class Ipex {
         this.client = client;
     }
 
+    /**
+     * Create an IPEX apply EXN message
+     */
+    async apply(args: IpexApplyArgs): Promise<[Serder, string[], string]> {
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: args.message ?? '',
+            s: args.schema,
+            a: args.attributes ?? {},
+            i: args.recipient,
+        };
+
+        return this.client
+            .exchanges()
+            .createExchangeMessage(
+                hab,
+                '/ipex/apply',
+                data,
+                {},
+                undefined,
+                args.datetime,
+                undefined
+            );
+    }
+
+    async submitApply(
+        name: string,
+        exn: Serder,
+        sigs: string[],
+        recp: string[]
+    ): Promise<any> {
+        const body = {
+            exn: exn.ked,
+            sigs,
+            rec: recp,
+        };
+
+        const response = await this.client.fetch(
+            `/identifiers/${name}/ipex/apply`,
+            'POST',
+            body
+        );
+
+        return response.json();
+    }
+
+    /**
+     * Create an IPEX offer EXN message
+     */
+    async offer(args: IpexOfferArgs): Promise<[Serder, string[], string]> {
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: args.message ?? '',
+        };
+
+        return this.client
+            .exchanges()
+            .createExchangeMessage(
+                hab,
+                '/ipex/offer',
+                data,
+                { acdc: [args.acdc, undefined] },
+                undefined,
+                args.datetime,
+                args.apply
+            );
+    }
+
+    async submitOffer(
+        name: string,
+        exn: Serder,
+        sigs: string[],
+        atc: string,
+        recp: string[]
+    ): Promise<any> {
+        const body = {
+            exn: exn.ked,
+            sigs,
+            atc,
+            rec: recp,
+        };
+
+        const response = await this.client.fetch(
+            `/identifiers/${name}/ipex/offer`,
+            'POST',
+            body
+        );
+
+        return response.json();
+    }
+
+    /**
+     * Create an IPEX agree EXN message
+     */
+    async agree(args: IpexAgreeArgs): Promise<[Serder, string[], string]> {
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: args.message ?? '',
+        };
+
+        return this.client
+            .exchanges()
+            .createExchangeMessage(
+                hab,
+                '/ipex/agree',
+                data,
+                {},
+                undefined,
+                args.datetime,
+                args.offer
+            );
+    }
+
+    async submitAgree(
+        name: string,
+        exn: Serder,
+        sigs: string[],
+        recp: string[]
+    ): Promise<any> {
+        const body = {
+            exn: exn.ked,
+            sigs,
+            rec: recp,
+        };
+
+        const response = await this.client.fetch(
+            `/identifiers/${name}/ipex/agree`,
+            'POST',
+            body
+        );
+
+        return response.json();
+    }
     /**
      * Create an IPEX grant EXN message
      */