signify-ts 0.2.1 → 0.3.0-dev.e31e78d

package/dist/keri/app/credentialing.js

@@ -0,0 +1,540 @@
+import { interact, messagize } from "../core/eventing.js";
+import { vdr } from "../core/vdring.js";
+import { b, d, Protocols, Ilks, Serials, versify, Vrsn_1_0, } from "../core/core.js";
+import { Saider } from "../core/saider.js";
+import { Serder } from "../core/serder.js";
+import { Siger } from "../core/siger.js";
+import { TraitDex } from "./habery.js";
+import { serializeACDCAttachment, serializeIssExnAttachment, } from "../core/utils.js";
+/** Types of credentials */
+export class CredentialTypes {
+}
+CredentialTypes.issued = 'issued';
+CredentialTypes.received = 'received';
+/**
+ * Credentials
+ */
+export class Credentials {
+    /**
+     * Credentials
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List credentials
+     * @async
+     * @param {CredentialFilter} [kargs] Optional parameters to filter the credentials
+     * @returns {Promise<CredentialResult[]>} A promise to the list of credentials
+     */
+    async list(kargs = {}) {
+        const path = `/credentials/query`;
+        const filtr = kargs.filter === undefined ? {} : kargs.filter;
+        const sort = kargs.sort === undefined ? [] : kargs.sort;
+        const limit = kargs.limit === undefined ? 25 : kargs.limit;
+        const skip = kargs.skip === undefined ? 0 : kargs.skip;
+        const data = {
+            filter: filtr,
+            sort: sort,
+            skip: skip,
+            limit: limit,
+        };
+        const method = 'POST';
+        const res = await this.client.fetch(path, method, data, undefined);
+        return await res.json();
+    }
+    async get(said, includeCESR = false) {
+        const path = `/credentials/${said}`;
+        const method = 'GET';
+        const headers = includeCESR
+            ? new Headers({ Accept: 'application/json+cesr' })
+            : new Headers({ Accept: 'application/json' });
+        const res = await this.client.fetch(path, method, null, headers);
+        return includeCESR ? await res.text() : await res.json();
+    }
+    /**
+     * Delete a credential from the DB
+     * @async
+     * @param {string} said - SAID of the credential
+     * @returns {Promise<void>}
+     */
+    async delete(said) {
+        const path = `/credentials/${said}`;
+        const method = 'DELETE';
+        await this.client.fetch(path, method, undefined);
+    }
+    /**
+     * Get the state of a credential
+     * @async
+     * @param {string} ri - management registry identifier
+     * @param {string} said - SAID of the credential
+     * @returns {Promise<CredentialState>} A promise to the credential registry state
+     */
+    async state(ri, said) {
+        const path = `/registries/${ri}/${said}`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return res.json();
+    }
+    /**
+     * Creates a credential in the specified registry to be GRANTed with IPEX to the intended recipient
+     */
+    async issue(name, args) {
+        var _a, _b;
+        const hab = await this.client.identifiers().get(name);
+        const estOnly = hab.state.c !== undefined && hab.state.c.includes('EO');
+        if (estOnly) {
+            // TODO implement rotation event
+            throw new Error('Establishment only not implemented');
+        }
+        if (!this.client.manager) {
+            throw new Error('No manager on client');
+        }
+        const keeper = this.client.manager.get(hab);
+        const [, subject] = Saider.saidify(Object.assign(Object.assign({ d: '' }, args.a), { dt: (_a = args.a.dt) !== null && _a !== void 0 ? _a : new Date().toISOString().replace('Z', '000+00:00') }));
+        const [, acdc] = Saider.saidify({
+            v: versify(Protocols.ACDC, undefined, Serials.JSON, 0),
+            d: '',
+            u: args.u,
+            i: (_b = args.i) !== null && _b !== void 0 ? _b : hab.prefix,
+            ri: args.ri,
+            s: args.s,
+            a: subject,
+            e: args.e,
+            r: args.r,
+        });
+        const [, iss] = Saider.saidify({
+            v: versify(Protocols.KERI, undefined, Serials.JSON, 0),
+            t: Ilks.iss,
+            d: '',
+            i: acdc.d,
+            s: '0',
+            ri: args.ri,
+            dt: subject.dt,
+        });
+        const sn = parseInt(hab.state.s, 16);
+        const anc = interact({
+            pre: hab.prefix,
+            sn: sn + 1,
+            data: [
+                {
+                    i: iss.i,
+                    s: iss.s,
+                    d: iss.d,
+                },
+            ],
+            dig: hab.state.d,
+            version: undefined,
+            kind: undefined,
+        });
+        const sigs = await keeper.sign(b(anc.raw));
+        const path = `/identifiers/${hab.name}/credentials`;
+        const method = 'POST';
+        const body = {
+            acdc: acdc,
+            iss: iss,
+            ixn: anc.sad,
+            sigs,
+            [keeper.algo]: keeper.params(),
+        };
+        const res = await this.client.fetch(path, method, body);
+        const op = await res.json();
+        return {
+            acdc: new Serder(acdc),
+            iss: new Serder(iss),
+            anc,
+            op,
+        };
+    }
+    /**
+     * Revoke credential
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} said SAID of the credential
+     * @param {string} datetime date time of revocation
+     * @returns {Promise<RevokeCredentialResult>} A promise to the long-running operation
+     */
+    async revoke(name, said, datetime) {
+        const hab = await this.client.identifiers().get(name);
+        const pre = hab.prefix;
+        const vs = versify(Protocols.KERI, undefined, Serials.JSON, 0);
+        const dt = datetime !== null && datetime !== void 0 ? datetime : new Date().toISOString().replace('Z', '000+00:00');
+        const cred = await this.get(said);
+        let registryId;
+        if ('ri' in cred.sad && cred.sad.ri !== undefined) {
+            registryId = cred.sad.ri;
+        }
+        else if ('rd' in cred.sad && cred.sad.rd !== undefined) {
+            registryId = cred.sad.rd;
+        }
+        else {
+            throw new Error('Neither ri nor rd property found in credential');
+        }
+        // Create rev
+        const _rev = {
+            v: vs,
+            t: Ilks.rev,
+            d: '',
+            i: said,
+            s: '1',
+            ri: registryId,
+            p: cred.status.d,
+            dt: dt,
+        };
+        const [, rev] = Saider.saidify(_rev);
+        // create ixn
+        let ixn = {};
+        let sigs = [];
+        const state = hab.state;
+        if (state.c !== undefined && state.c.includes('EO')) {
+            var estOnly = true;
+        }
+        else {
+            var estOnly = false;
+        }
+        const sn = parseInt(state.s, 16);
+        const dig = state.d;
+        const data = [
+            {
+                i: rev.i,
+                s: rev.s,
+                d: rev.d,
+            },
+        ];
+        const keeper = this.client.manager.get(hab);
+        if (estOnly) {
+            // TODO implement rotation event
+            throw new Error('Establishment only not implemented');
+        }
+        else {
+            const serder = interact({
+                pre: pre,
+                sn: sn + 1,
+                data: data,
+                dig: dig,
+                version: undefined,
+                kind: undefined,
+            });
+            sigs = await keeper.sign(b(serder.raw));
+            ixn = serder.sad;
+        }
+        const body = {
+            rev: rev,
+            ixn: ixn,
+            sigs: sigs,
+            [keeper.algo]: keeper.params(),
+        };
+        const path = `/identifiers/${name}/credentials/${said}`;
+        const method = 'DELETE';
+        const res = await this.client.fetch(path, method, body);
+        const op = await res.json();
+        return {
+            rev: new Serder(rev),
+            anc: new Serder(ixn),
+            op,
+        };
+    }
+}
+export class RegistryResult {
+    constructor(regser, serder, sigs, promise) {
+        this._regser = regser;
+        this._serder = serder;
+        this._sigs = sigs;
+        this.promise = promise;
+    }
+    get regser() {
+        return this._regser;
+    }
+    get serder() {
+        return this._serder;
+    }
+    get sigs() {
+        return this._sigs;
+    }
+    async op() {
+        const res = await this.promise;
+        return await res.json();
+    }
+}
+/**
+ * Registries
+ */
+export class Registries {
+    /**
+     * Registries
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List registries
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @returns {Promise<Registry[]>} A promise to the list of registries
+     */
+    async list(name) {
+        const path = `/identifiers/${name}/registries`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+    /**
+     * Create a registry
+     * @async
+     * @param {CreateRegistryArgs}
+     * @returns {Promise<[any, Serder, any[], object]> } A promise to the long-running operation
+     */
+    async create({ name, registryName, noBackers = true, toad = 0, baks = [], nonce, }) {
+        const hab = await this.client.identifiers().get(name);
+        const pre = hab.prefix;
+        const cnfg = [];
+        if (noBackers) {
+            cnfg.push(TraitDex.NoBackers);
+        }
+        const state = hab.state;
+        const estOnly = state.c !== undefined && state.c.includes('EO');
+        if (estOnly) {
+            cnfg.push(TraitDex.EstOnly);
+        }
+        const regser = vdr.incept({ pre, baks, toad, nonce, cnfg });
+        if (estOnly) {
+            throw new Error('establishment only not implemented');
+        }
+        else {
+            const state = hab.state;
+            const sn = parseInt(state.s, 16);
+            const dig = state.d;
+            const data = [
+                {
+                    i: regser.pre,
+                    s: '0',
+                    d: regser.pre,
+                },
+            ];
+            const serder = interact({
+                pre: pre,
+                sn: sn + 1,
+                data: data,
+                dig: dig,
+                version: Vrsn_1_0,
+                kind: Serials.JSON,
+            });
+            const keeper = this.client.manager.get(hab);
+            const sigs = await keeper.sign(b(serder.raw));
+            const res = this.createFromEvents(hab, name, registryName, regser.sad, serder.sad, sigs);
+            return new RegistryResult(regser, serder, sigs, res);
+        }
+    }
+    createFromEvents(hab, name, registryName, vcp, ixn, sigs) {
+        const path = `/identifiers/${name}/registries`;
+        const method = 'POST';
+        const data = {
+            name: registryName,
+            vcp: vcp,
+            ixn: ixn,
+            sigs: sigs,
+        };
+        const keeper = this.client.manager.get(hab);
+        data[keeper.algo] = keeper.params();
+        return this.client.fetch(path, method, data);
+    }
+    /**
+     * Rename a registry
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} registryName Current registry name
+     * @param {string} newName New registry name
+     * @returns {Promise<Registry>} A promise to the registry record
+     */
+    async rename(name, registryName, newName) {
+        const path = `/identifiers/${name}/registries/${registryName}`;
+        const method = 'PUT';
+        const data = {
+            name: newName,
+        };
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+}
+/**
+ * Schemas
+ */
+export class Schemas {
+    /**
+     * Schemas
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a schema
+     * @async
+     * @param {string} said SAID of the schema
+     * @returns {Promise<Schema>} A promise to the schema
+     */
+    async get(said) {
+        const path = `/schema/${said}`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+    /**
+     * List schemas
+     * @async
+     * @returns {Promise<Schema[]>} A promise to the list of schemas
+     */
+    async list() {
+        const path = `/schema`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+}
+/**
+ * Ipex
+ */
+export class Ipex {
+    /**
+     * Schemas
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create an IPEX apply EXN message
+     */
+    async apply(args) {
+        var _a, _b;
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: (_a = args.message) !== null && _a !== void 0 ? _a : '',
+            s: args.schemaSaid,
+            a: (_b = args.attributes) !== null && _b !== void 0 ? _b : {},
+        };
+        return this.client
+            .exchanges()
+            .createExchangeMessage(hab, '/ipex/apply', data, {}, args.recipient, args.datetime, undefined);
+    }
+    async submitApply(name, exn, sigs, recp) {
+        const body = {
+            exn: exn.sad,
+            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) {
+        var _a;
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: (_a = args.message) !== null && _a !== void 0 ? _a : '',
+        };
+        return this.client
+            .exchanges()
+            .createExchangeMessage(hab, '/ipex/offer', data, { acdc: [args.acdc, undefined] }, args.recipient, args.datetime, args.applySaid);
+    }
+    async submitOffer(name, exn, sigs, atc, recp) {
+        const body = {
+            exn: exn.sad,
+            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) {
+        var _a;
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: (_a = args.message) !== null && _a !== void 0 ? _a : '',
+        };
+        return this.client
+            .exchanges()
+            .createExchangeMessage(hab, '/ipex/agree', data, {}, args.recipient, args.datetime, args.offerSaid);
+    }
+    async submitAgree(name, exn, sigs, recp) {
+        const body = {
+            exn: exn.sad,
+            sigs,
+            rec: recp,
+        };
+        const response = await this.client.fetch(`/identifiers/${name}/ipex/agree`, 'POST', body);
+        return response.json();
+    }
+    /**
+     * Create an IPEX grant EXN message
+     */
+    async grant(args) {
+        var _a;
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: (_a = args.message) !== null && _a !== void 0 ? _a : '',
+        };
+        let atc = args.ancAttachment;
+        if (atc === undefined) {
+            const keeper = this.client.manager.get(hab);
+            const sigs = await keeper.sign(b(args.anc.raw));
+            const sigers = sigs.map((sig) => new Siger({ qb64: sig }));
+            const ims = d(messagize(args.anc, sigers));
+            atc = ims.substring(args.anc.size);
+        }
+        const acdcAtc = args.acdcAttachment === undefined
+            ? d(serializeACDCAttachment(args.iss))
+            : args.acdcAttachment;
+        const issAtc = args.issAttachment === undefined
+            ? d(serializeIssExnAttachment(args.anc))
+            : args.issAttachment;
+        const embeds = {
+            acdc: [args.acdc, acdcAtc],
+            iss: [args.iss, issAtc],
+            anc: [args.anc, atc],
+        };
+        return this.client
+            .exchanges()
+            .createExchangeMessage(hab, '/ipex/grant', data, embeds, args.recipient, args.datetime, args.agreeSaid);
+    }
+    async submitGrant(name, exn, sigs, atc, recp) {
+        const body = {
+            exn: exn.sad,
+            sigs: sigs,
+            atc: atc,
+            rec: recp,
+        };
+        const response = await this.client.fetch(`/identifiers/${name}/ipex/grant`, 'POST', body);
+        return response.json();
+    }
+    /**
+     * Create an IPEX admit EXN message
+     */
+    async admit(args) {
+        const hab = await this.client.identifiers().get(args.senderName);
+        const data = {
+            m: args.message,
+        };
+        return this.client
+            .exchanges()
+            .createExchangeMessage(hab, '/ipex/admit', data, {}, args.recipient, args.datetime, args.grantSaid);
+    }
+    async submitAdmit(name, exn, sigs, atc, recp) {
+        const body = {
+            exn: exn.sad,
+            sigs: sigs,
+            atc: atc,
+            rec: recp,
+        };
+        const response = await this.client.fetch(`/identifiers/${name}/ipex/admit`, 'POST', body);
+        return response.json();
+    }
+}

package/dist/keri/app/delegating.d.ts

@@ -0,0 +1,18 @@
+import { EventResult } from './aiding.ts';
+import { SignifyClient } from './clienting.ts';
+export declare class Delegations {
+    client: SignifyClient;
+    /**
+     * Delegations
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Approve the delegation via interaction event
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {any} [data] The anchoring interaction event
+     * @returns {Promise<EventResult>} A promise to the delegated approval result
+     */
+    approve(name: string, data?: any): Promise<EventResult>;
+}

package/dist/keri/app/delegating.js

@@ -0,0 +1,24 @@
+import { EventResult } from "./aiding.js";
+export class Delegations {
+    /**
+     * Delegations
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Approve the delegation via interaction event
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {any} [data] The anchoring interaction event
+     * @returns {Promise<EventResult>} A promise to the delegated approval result
+     */
+    async approve(name, data) {
+        const { serder, sigs, jsondata } = await this.client
+            .identifiers()
+            .createInteract(name, data);
+        const res = await this.client.fetch('/identifiers/' + name + '/delegation', 'POST', jsondata);
+        return new EventResult(serder, sigs, res);
+    }
+}

package/dist/keri/app/escrowing.d.ts

@@ -1,4 +1,6 @@
-import { SignifyClient } from './clienting';
+import { SignifyClient } from './clienting.ts';
+import { components } from '../../types/keria-api-schema.ts';
+export type Rpy = components['schemas']['Rpy'];
 /**
  * Escrows
  */
@@ -13,7 +15,7 @@ export declare class Escrows {
      * List replay messages
      * @async
      * @param {string} [route] Optional route in the replay message
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Rpy[]>} A promise to the list of replay messages
      */
-    listReply(route?: string): Promise<any>;
+    listReply(route?: string): Promise<Rpy[]>;
 }

package/{src/keri/app/escrowing.ts → dist/keri/app/escrowing.js}

@@ -1,31 +1,25 @@
-import { SignifyClient } from './clienting';
-
 /**
  * Escrows
  */
 export class Escrows {
-    client: SignifyClient;
-
     /**
      * Escrows
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * List replay messages
      * @async
      * @param {string} [route] Optional route in the replay message
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Rpy[]>} A promise to the list of replay messages
      */
-    async listReply(route?: string): Promise<any> {
+    async listReply(route) {
         const params = new URLSearchParams();
         if (route !== undefined) {
             params.append('route', route);
         }
-
         const path = `/escrows/rpy` + '?' + params.toString();
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);