signify-ts 0.1.0 → 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

@@ -0,0 +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';
+
+export class TraitCodex {
+    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 interface HaberyArgs {
+    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;
+}
+
+export class Hab {
+    public name: string;
+    public serder: Serder;
+
+    constructor(name: string, icp: Serder) {
+        this.name = name;
+        this.serder = icp;
+    }
+
+    get pre(): string {
+        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>();
+
+    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.');
+            }
+
+            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
+            }
+        }
+        let algo;
+        const salter =
+            salt != undefined ? new Salter({ qb64: salt }) : undefined;
+        if (salt != undefined) {
+            algo = Algos.salty;
+        } else {
+            algo = Algos.randy;
+        }
+
+        this._mgr = new Manager({
+            seed: seed,
+            aeid: aeid,
+            pidx: pidx,
+            algo: algo,
+            salter: salter,
+        });
+    }
+
+    get mgr(): Manager {
+        return this._mgr;
+    }
+
+    get habs(): Array<Hab> {
+        return Array.from(this._habs.values());
+    }
+
+    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 {
+        if (nsith == undefined) {
+            nsith = isith;
+        }
+        if (ncount == undefined) {
+            ncount = icount;
+        }
+        if (!transferable) {
+            ncount = 0;
+            nsith = '0';
+            code = MtrDex.Ed25519N;
+        }
+
+        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;
+        if (isith == undefined) {
+            isith = `${Math.max(1, Math.ceil(icount / 2)).toString(16)}`;
+        }
+        if (nsith == undefined) {
+            nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
+        }
+
+        const cnfg = new Array<string>();
+        if (estOnly) {
+            cnfg.push(TraitDex.EstOnly);
+        }
+        if (DnD) {
+            cnfg.push(TraitDex.DoNotDelegate);
+        }
+
+        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;
+    }
+}

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);
+    }
+}

package/src/keri/core/authing.ts

@@ -0,0 +1,117 @@
+import { Signer } from './signer';
+import { Verfer } from './verfer';
+import { desiginput, normalize, siginput } from './httping';
+import { Signage, signature, designature } from '../end/ending';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+export class Authenticater {
+    static DefaultFields = [
+        '@method',
+        '@path',
+        'signify-resource',
+        'signify-timestamp',
+    ];
+    private _verfer: Verfer;
+    private readonly _csig: Signer;
+
+    constructor(csig: Signer, verfer: Verfer) {
+        this._csig = csig;
+        this._verfer = verfer;
+    }
+
+    verify(headers: Headers, method: string, path: string): boolean {
+        const siginput = headers.get('Signature-Input');
+        if (siginput == null) {
+            return false;
+        }
+        const signature = headers.get('Signature');
+        if (signature == null) {
+            return false;
+        }
+        let inputs = desiginput(siginput);
+        inputs = inputs.filter((input) => input.name == 'signify');
+        if (inputs.length == 0) {
+            return false;
+        }
+        inputs.forEach((input) => {
+            const items = new Array<string>();
+            input.fields!.forEach((field: string) => {
+                if (field.startsWith('@')) {
+                    if (field == '@method') {
+                        items.push(`"${field}": ${method}`);
+                    } else if (field == '@path') {
+                        items.push(`"${field}": ${path}`);
+                    }
+                } else {
+                    if (headers.has(field)) {
+                        const value = normalize(headers.get(field) as string);
+                        items.push(`"${field}": ${value}`);
+                    }
+                }
+            });
+            const values = new Array<string>();
+            values.push(`(${input.fields!.join(' ')})`);
+            values.push(`created=${input.created}`);
+            if (input.expires != undefined) {
+                values.push(`expires=${input.expires}`);
+            }
+            if (input.nonce != undefined) {
+                values.push(`nonce=${input.nonce}`);
+            }
+            if (input.keyid != undefined) {
+                values.push(`keyid=${input.keyid}`);
+            }
+            if (input.context != undefined) {
+                values.push(`context=${input.context}`);
+            }
+            if (input.alg != undefined) {
+                values.push(`alg=${input.alg}`);
+            }
+            const params = values.join(';');
+            items.push(`"@signature-params: ${params}"`);
+            const ser = items.join('\n');
+            const signage = designature(signature!);
+            const cig = signage[0].markers.get(input.name);
+            if (!this._verfer.verify(cig.raw, ser)) {
+                throw new Error(`Signature for ${input.keyid} invalid.`);
+            }
+        });
+
+        return true;
+    }
+
+    sign(
+        headers: Headers,
+        method: string,
+        path: string,
+        fields?: Array<string>
+    ): Headers {
+        if (fields == undefined) {
+            fields = Authenticater.DefaultFields;
+        }
+
+        const [header, sig] = siginput(this._csig, {
+            name: 'signify',
+            method,
+            path,
+            headers,
+            fields,
+            alg: 'ed25519',
+            keyid: this._csig.verfer.qb64,
+        });
+
+        header.forEach((value, key) => {
+            headers.append(key, value);
+        });
+
+        const markers = new Map<string, Siger | Cigar>();
+        markers.set('signify', sig);
+        const signage = new Signage(markers, false);
+        const signed = signature([signage]);
+        signed.forEach((value, key) => {
+            headers.append(key, value);
+        });
+
+        return headers;
+    }
+}