signify-ts 0.1.1 → 0.2.0

package/src/keri/app/escrowing.ts

@@ -0,0 +1,34 @@
+import { SignifyClient } from './clienting';
+
+/**
+ * Escrows
+ */
+export class Escrows {
+    client: SignifyClient;
+
+    /**
+     * Escrows
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient) {
+        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
+     */
+    async listReply(route?: string): Promise<any> {
+        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);
+        return await res.json();
+    }
+}

package/src/keri/app/exchanging.ts

@@ -0,0 +1,220 @@
+import { SignifyClient } from './clienting';
+import { b, d, Dict, Ident, Ilks, Serials, versify } from '../core/core';
+import { Serder } from '../core/serder';
+import { nowUTC } from '../core/utils';
+import { Pather } from '../core/pather';
+import { Counter, CtrDex } from '../core/counter';
+import { Saider } from '../core/saider';
+
+/**
+ * Exchanges
+ */
+export class Exchanges {
+    client: SignifyClient;
+
+    /**
+     * Exchanges
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient) {
+        this.client = client;
+    }
+
+    /**
+     * Create exn message
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipient
+     * @param datetime
+     * @param dig
+     */
+    async createExchangeMessage(
+        sender: Dict<any>,
+        route: string,
+        payload: Dict<any>,
+        embeds: Dict<any>,
+        recipient?: string,
+        datetime?: string,
+        dig?: string
+    ): Promise<[Serder, string[], string]> {
+        const keeper = this.client.manager!.get(sender);
+        const [exn, end] = exchange(
+            route,
+            payload,
+            sender['prefix'],
+            recipient,
+            datetime,
+            dig,
+            undefined,
+            embeds
+        );
+
+        const sigs = await keeper.sign(b(exn.raw));
+        return [exn, sigs, d(end)];
+    }
+
+    /**
+     * Send exn messages to list of recipients
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipients
+     */
+    async send(
+        name: string,
+        topic: string,
+        sender: Dict<any>,
+        route: string,
+        payload: Dict<any>,
+        embeds: Dict<any>,
+        recipients: string[]
+    ): Promise<any> {
+        const [exn, sigs, atc] = await this.createExchangeMessage(
+            sender,
+            route,
+            payload,
+            embeds
+        );
+        return await this.sendFromEvents(
+            name,
+            topic,
+            exn,
+            sigs,
+            atc,
+            recipients
+        );
+    }
+
+    /**
+     * Send exn messaget to list of recipients
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param exn
+     * @param sigs
+     * @param atc
+     * @param recipients
+     */
+    async sendFromEvents(
+        name: string,
+        topic: string,
+        exn: Serder,
+        sigs: string[],
+        atc: string,
+        recipients: string[]
+    ): Promise<any> {
+        const path = `/identifiers/${name}/exchanges`;
+        const method = 'POST';
+        const data: any = {
+            tpc: topic,
+            exn: exn.ked,
+            sigs: sigs,
+            atc: atc,
+            rec: recipients,
+        };
+
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+
+    /**
+     * Get exn message by said
+     * @async
+     * @returns A promise to the exn message
+     * @param said The said of the exn message
+     */
+    async get(said: string): Promise<any> {
+        const path = `/exchanges/${said}`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+}
+
+export function exchange(
+    route: string,
+    payload: Dict<any>,
+    sender: string,
+    recipient?: string,
+    date?: string,
+    dig?: string,
+    modifiers?: Dict<any>,
+    embeds?: Dict<any>
+): [Serder, Uint8Array] {
+    const vs = versify(Ident.KERI, undefined, Serials.JSON, 0);
+    const ilk = Ilks.exn;
+    const dt =
+        date !== undefined
+            ? date
+            : nowUTC().toISOString().replace('Z', '000+00:00');
+    const p = dig !== undefined ? dig : '';
+    const q = modifiers !== undefined ? modifiers : {};
+    const ems = embeds != undefined ? embeds : {};
+
+    let e = {} as Dict<any>;
+    let end = '';
+    Object.entries(ems).forEach(([key, value]) => {
+        const serder = value[0];
+        const atc = value[1];
+        e[key] = serder.ked;
+
+        if (atc == undefined) {
+            return;
+        }
+        let pathed = '';
+        const pather = new Pather({}, undefined, ['e', key]);
+        pathed += pather.qb64;
+        pathed += atc;
+
+        const counter = new Counter({
+            code: CtrDex.PathedMaterialQuadlets,
+            count: Math.floor(pathed.length / 4),
+        });
+        end += counter.qb64;
+        end += pathed;
+    });
+
+    if (Object.keys(e).length > 0) {
+        e['d'] = '';
+        [, e] = Saider.saidify(e);
+    }
+
+    const attrs = {} as Dict<any>;
+
+    if (recipient !== undefined) {
+        attrs['i'] = recipient;
+    }
+
+    const a = {
+        ...attrs,
+        ...payload,
+    };
+
+    const _ked = {
+        v: vs,
+        t: ilk,
+        d: '',
+        i: sender,
+        p: p,
+        dt: dt,
+        r: route,
+        q: q,
+        a: a,
+        e: e,
+    };
+    const [, ked] = Saider.saidify(_ked);
+
+    const exn = new Serder(ked);
+
+    return [exn, b(end)];
+}

package/src/keri/app/grouping.ts

@@ -0,0 +1,90 @@
+import { SignifyClient } from './clienting';
+import { Dict } from '../core/core';
+
+/**
+ * Groups
+ */
+export class Groups {
+    client: SignifyClient;
+
+    /**
+     * Groups
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient) {
+        this.client = client;
+    }
+
+    /**
+     * Get group request messages
+     * @async
+     * @param {string} [said] SAID of exn message to load
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    async getRequest(said: string): Promise<any> {
+        const path = `/multisig/request/` + said;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+
+    /**
+     * Send multisig exn request  messages to other group members
+     * @async
+     * @param {string} [name] human readable name of group AID
+     * @param {Dict<any>} [exn] exn message to send to other members
+     * @param {string[]} [sigs] signature of the participant over the exn
+     * @param {string} [atc] additional attachments from embedded events in exn
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    async sendRequest(
+        name: string,
+        exn: Dict<any>,
+        sigs: string[],
+        atc: string
+    ): Promise<any> {
+        const path = `/identifiers/${name}/multisig/request`;
+        const method = 'POST';
+        const data = {
+            exn: exn,
+            sigs: sigs,
+            atc: atc,
+        };
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+
+    /**
+     * Join multisig group using rotation event.
+     * This can be used by participants being asked to contribute keys to a rotation event to join an existing group.
+     * @async
+     * @param {string} [name] human readable name of group AID
+     * @param {any} [rot] rotation event
+     * @param {any} [sigs] signatures
+     * @param {string} [gid] prefix
+     * @param {string[]} [smids] array of particpants
+     * @param {string[]} [rmids] array of particpants
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    async join(
+        name: string,
+        rot: any,
+        sigs: any, //string[],
+        gid: string,
+        smids: string[],
+        rmids: string[]
+    ): Promise<any> {
+        const path = `/identifiers/${name}/multisig/join`;
+        const method = 'POST';
+        const data = {
+            tpc: 'multisig',
+            rot: rot.ked,
+            sigs: sigs,
+            gid: gid,
+            smids: smids,
+            rmids: rmids,
+        };
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+}

package/src/keri/app/habery.ts

@@ -1,152 +1,185 @@
-import {Algos, Manager} from "../core/manager";
-import {MtrDex} from "../core/matter";
-import {Salter} from "../core/salter";
-import {Verfer} from "../core/verfer";
-import {Diger} from "../core/diger";
-import {incept} from "../core/eventing";
-import {Serder} from "../core/serder";
-
+import { Algos, Manager } from '../core/manager';
+import { MtrDex } from '../core/matter';
+import { Salter } from '../core/salter';
+import { Verfer } from '../core/verfer';
+import { Diger } from '../core/diger';
+import { incept } from '../core/eventing';
+import { Serder } from '../core/serder';
 
 export class TraitCodex {
-    EstOnly: string = 'EO'  // Only allow establishment events
-    DoNotDelegate: string = 'DND'  // Dot not allow delegated identifiers
+    EstOnly: string = 'EO'; // Only allow establishment events
+    DoNotDelegate: string = 'DND'; // Dot not allow delegated identifiers
+    NoBackers: string = 'NB'; // Do not allow backers
 }
 
-export const TraitDex = new TraitCodex()
+export const TraitDex = new TraitCodex();
 
 export interface HaberyArgs {
-    name: string
-    passcode?: string
-    seed?: string | undefined
-    aeid?: string | undefined
-    pidx?: number | undefined
-    salt?: string | undefined
-    tier?: string | undefined
-
+    name: string;
+    passcode?: string;
+    seed?: string | undefined;
+    aeid?: string | undefined;
+    pidx?: number | undefined;
+    salt?: string | undefined;
+    tier?: string | undefined;
 }
 
 export interface MakeHabArgs {
-    code?: string
-    transferable?: boolean
-    isith?: string
-    icount?: number
-    nsith?: string
-    ncount?: number
-    toad?: string | number
-    wits?: Array<string>
-    delpre?: string
-    estOnly?: boolean
-    DnD?: boolean
-    data?: any
+    code?: string;
+    transferable?: boolean;
+    isith?: string;
+    icount?: number;
+    nsith?: string;
+    ncount?: number;
+    toad?: string | number;
+    wits?: Array<string>;
+    delpre?: string;
+    estOnly?: boolean;
+    DnD?: boolean;
+    data?: any;
 }
 
 export class Hab {
-    public name: string
-    public serder: Serder
+    public name: string;
+    public serder: Serder;
 
     constructor(name: string, icp: Serder) {
-        this.name = name
-        this.serder = icp
+        this.name = name;
+        this.serder = icp;
     }
 
     get pre(): string {
-        return this.serder.ked["i"]
+        return this.serder.ked['i'];
     }
 }
 
-
 export class Habery {
     private readonly _name: string;
     private readonly _mgr: Manager;
-    private readonly _habs: Map<string, Hab> = new Map<string, Hab>()
+    private readonly _habs: Map<string, Hab> = new Map<string, Hab>();
 
-    constructor({name, passcode, seed, aeid, pidx, salt}: HaberyArgs) {
-        this._name = name
+    constructor({ name, passcode, seed, aeid, pidx, salt }: HaberyArgs) {
+        this._name = name;
         if (passcode != undefined && seed == undefined) {
             if (passcode.length < 21) {
-                throw new Error("Bran (passcode seed material) too short.")
+                throw new Error('Bran (passcode seed material) too short.');
             }
 
-            let bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21)  // qb64 salt for seed
-            let signer = new Salter({qb64: bran}).signer(MtrDex.Ed25519_Seed, false)
-            seed = signer.qb64
+            const bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21); // qb64 salt for seed
+            const signer = new Salter({ qb64: bran }).signer(
+                MtrDex.Ed25519_Seed,
+                false
+            );
+            seed = signer.qb64;
             if (aeid == undefined) {
-                aeid = signer.verfer.qb64  // lest it remove encryption
+                aeid = signer.verfer.qb64; // lest it remove encryption
             }
         }
         let algo;
-
+        const salter =
+            salt != undefined ? new Salter({ qb64: salt }) : undefined;
         if (salt != undefined) {
-            algo = Algos.salty
-            salt = new Salter({qb64: salt}).qb64
+            algo = Algos.salty;
         } else {
-            algo = Algos.randy
+            algo = Algos.randy;
         }
 
-        this._mgr = new Manager({seed: seed, aeid: aeid, pidx: pidx, algo: algo, salt: salt})
+        this._mgr = new Manager({
+            seed: seed,
+            aeid: aeid,
+            pidx: pidx,
+            algo: algo,
+            salter: salter,
+        });
     }
 
     get mgr(): Manager {
-        return this._mgr
+        return this._mgr;
     }
 
     get habs(): Array<Hab> {
-        return Array.from(this._habs.values())
+        return Array.from(this._habs.values());
     }
 
-    habByName(name: string): Hab|undefined {
-        return this._habs.get(name)
+    habByName(name: string): Hab | undefined {
+        return this._habs.get(name);
     }
 
-    makeHab(name:string, {code = MtrDex.Blake3_256, transferable = true, isith = undefined, icount = 1,
-                          nsith = undefined, ncount = undefined, toad = undefined, wits = undefined, delpre = undefined,
-                          estOnly = false, DnD = false, data = undefined}: MakeHabArgs): Hab {
-
+    makeHab(
+        name: string,
+        {
+            code = MtrDex.Blake3_256,
+            transferable = true,
+            isith = undefined,
+            icount = 1,
+            nsith = undefined,
+            ncount = undefined,
+            toad = undefined,
+            wits = undefined,
+            delpre = undefined,
+            estOnly = false,
+            DnD = false,
+            data = undefined,
+        }: MakeHabArgs
+    ): Hab {
         if (nsith == undefined) {
-            nsith = isith
+            nsith = isith;
         }
         if (ncount == undefined) {
-            ncount = icount
+            ncount = icount;
         }
         if (!transferable) {
-            ncount = 0
-            nsith = "0"
-            code = MtrDex.Ed25519N
+            ncount = 0;
+            nsith = '0';
+            code = MtrDex.Ed25519N;
         }
 
-        let [verfers, digers] = this._mgr.incept({
-            icount: icount, ncount: ncount, stem: this.name,
-            transferable: transferable, temp: false
-        })
+        const [verfers, digers] = this._mgr.incept({
+            icount: icount,
+            ncount: ncount,
+            stem: this.name,
+            transferable: transferable,
+            temp: false,
+        });
 
-        icount = verfers.length
-        ncount = digers != undefined ? digers.length : 0
+        icount = verfers.length;
+        ncount = digers != undefined ? digers.length : 0;
         if (isith == undefined) {
-            isith = `${Math.max(1, Math.ceil(icount/2)).toString(16)}`
+            isith = `${Math.max(1, Math.ceil(icount / 2)).toString(16)}`;
         }
         if (nsith == undefined) {
-            nsith = `${Math.max(1, Math.ceil(ncount/2)).toString(16)}`
+            nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
         }
 
-        let cnfg = new Array<string>()
+        const cnfg = new Array<string>();
         if (estOnly) {
-            cnfg.push(TraitDex.EstOnly)
+            cnfg.push(TraitDex.EstOnly);
         }
-        if(DnD) {
-            cnfg.push(TraitDex.DoNotDelegate)
+        if (DnD) {
+            cnfg.push(TraitDex.DoNotDelegate);
         }
 
-        let keys = Array.from(verfers, (verfer: Verfer) => verfer.qb64)
-        let ndigs = Array.from(digers, (diger: Diger) => diger.qb64)
-
-
-        const icp = incept({keys, isith, ndigs, nsith, toad, wits, cnfg, data, code, delpre})
-        const hab = new Hab(name, icp)
-        this._habs.set(name, hab)
-        return hab
+        const keys = Array.from(verfers, (verfer: Verfer) => verfer.qb64);
+        const ndigs = Array.from(digers, (diger: Diger) => diger.qb64);
+
+        const icp = incept({
+            keys,
+            isith,
+            ndigs,
+            nsith,
+            toad,
+            wits,
+            cnfg,
+            data,
+            code,
+            delpre,
+        });
+        const hab = new Hab(name, icp);
+        this._habs.set(name, hab);
+        return hab;
     }
 
     get name(): string {
-        return this._name
+        return this._name;
     }
-}
+}

package/src/keri/app/notifying.ts

@@ -0,0 +1,69 @@
+import { SignifyClient } from './clienting';
+import { parseRangeHeaders } from '../core/httping';
+
+/**
+ * Notifications
+ */
+export class Notifications {
+    client: SignifyClient;
+
+    /**
+     * Notifications
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient) {
+        this.client = client;
+    }
+
+    /**
+     * List notifications
+     * @async
+     * @param {number} [start=0] Start index of list of notifications, defaults to 0
+     * @param {number} [end=24] End index of list of notifications, defaults to 24
+     * @returns {Promise<any>} A promise to the list of notifications
+     */
+    async list(start: number = 0, end: number = 24): Promise<any> {
+        const extraHeaders = new Headers();
+        extraHeaders.append('Range', `notes=${start}-${end}`);
+
+        const path = `/notifications`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null, extraHeaders);
+
+        const cr = res.headers.get('content-range');
+        const range = parseRangeHeaders(cr, 'notes');
+        const notes = await res.json();
+
+        return {
+            start: range.start,
+            end: range.end,
+            total: range.total,
+            notes: notes,
+        };
+    }
+
+    /**
+     * Mark a notification as read
+     * @async
+     * @param {string} said SAID of the notification
+     * @returns {Promise<string>} A promise to the result of the marking
+     */
+    async mark(said: string): Promise<string> {
+        const path = `/notifications/` + said;
+        const method = 'PUT';
+        const res = await this.client.fetch(path, method, null);
+        return await res.text();
+    }
+
+    /**
+     * Delete a notification
+     * @async
+     * @param {string} said SAID of the notification
+     * @returns {Promise<any>} A promise to the result of the deletion
+     */
+    async delete(said: string): Promise<void> {
+        const path = `/notifications/` + said;
+        const method = 'DELETE';
+        await this.client.fetch(path, method, null);
+    }
+}