signify-ts 0.2.1 → 0.3.0-rc2

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

@@ -1,25 +1,20 @@
-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';
-
+import { b, d, Protocols, Ilks, Serials, versify } from "../core/core.js";
+import { Serder } from "../core/serder.js";
+import { nowUTC } from "../core/utils.js";
+import { Pather } from "../core/pather.js";
+import { Counter, CtrDex } from "../core/counter.js";
+import { Saider } from "../core/saider.js";
 /**
  * Exchanges
  */
 export class Exchanges {
-    client: SignifyClient;
-
     /**
      * Exchanges
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * Create exn message
      * @async
@@ -32,31 +27,12 @@ export class Exchanges {
      * @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
-        );
-
+    async createExchangeMessage(sender, route, payload, embeds, recipient, datetime, dig) {
+        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
@@ -69,31 +45,12 @@ export class Exchanges {
      * @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
-        );
+    async send(name, topic, sender, route, payload, embeds, recipients) {
+        for (const recipient of recipients) {
+            const [exn, sigs, atc] = await this.createExchangeMessage(sender, route, payload, embeds, recipient);
+            return await this.sendFromEvents(name, topic, exn, sigs, atc, recipients);
+        }
     }
-
     /**
      * Send exn messaget to list of recipients
      * @async
@@ -105,69 +62,47 @@ export class Exchanges {
      * @param atc
      * @param recipients
      */
-    async sendFromEvents(
-        name: string,
-        topic: string,
-        exn: Serder,
-        sigs: string[],
-        atc: string,
-        recipients: string[]
-    ): Promise<any> {
+    async sendFromEvents(name, topic, exn, sigs, atc, recipients) {
         const path = `/identifiers/${name}/exchanges`;
         const method = 'POST';
-        const data: any = {
+        const data = {
             tpc: topic,
-            exn: exn.ked,
+            exn: exn.sad,
             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> {
+    async get(said) {
         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);
+export function exchange(route, payload, sender, recipient, date, dig, modifiers, embeds) {
+    const vs = versify(Protocols.KERI, undefined, Serials.JSON, 0);
     const ilk = Ilks.exn;
-    const dt =
-        date !== undefined
-            ? date
-            : nowUTC().toISOString().replace('Z', '000+00:00');
+    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 e = {};
     let end = '';
     Object.entries(ems).forEach(([key, value]) => {
         const serder = value[0];
         const atc = value[1];
-        e[key] = serder.ked;
-
+        e[key] = serder.sad;
         if (atc == undefined) {
             return;
         }
@@ -175,7 +110,6 @@ export function exchange(
         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),
@@ -183,28 +117,19 @@ export function exchange(
         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 = {
+    const attrs = {};
+    attrs['i'] = recipient;
+    const a = Object.assign(Object.assign({}, attrs), payload);
+    const _sad = {
         v: vs,
         t: ilk,
         d: '',
         i: sender,
+        rp: recipient,
         p: p,
         dt: dt,
         r: route,
@@ -212,9 +137,7 @@ export function exchange(
         a: a,
         e: e,
     };
-    const [, ked] = Saider.saidify(_ked);
-
-    const exn = new Serder(ked);
-
+    const [, sad] = Saider.saidify(_sad);
+    const exn = new Serder(sad);
     return [exn, b(end)];
 }

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

@@ -1,5 +1,5 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
+import { SignifyClient } from './clienting.ts';
+import { Dict } from '../core/core.ts';
 /**
  * Groups
  */

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

@@ -1,33 +1,26 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
-
 /**
  * Groups
  */
 export class Groups {
-    client: SignifyClient;
-
     /**
      * Groups
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         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> {
+    async getRequest(said) {
         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
@@ -37,12 +30,7 @@ export class Groups {
      * @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> {
+    async sendRequest(name, exn, sigs, atc) {
         const path = `/identifiers/${name}/multisig/request`;
         const method = 'POST';
         const data = {
@@ -53,7 +41,6 @@ export class Groups {
         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.
@@ -66,19 +53,13 @@ export class Groups {
      * @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> {
+    async join(name, rot, sigs, //string[],
+    gid, smids, rmids) {
         const path = `/identifiers/${name}/multisig/join`;
         const method = 'POST';
         const data = {
             tpc: 'multisig',
-            rot: rot.ked,
+            rot: rot.sad,
             sigs: sigs,
             gid: gid,
             smids: smids,

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

@@ -1,5 +1,5 @@
-import { Manager } from '../core/manager';
-import { Serder } from '../core/serder';
+import { Manager } from '../core/manager.ts';
+import { Serder } from '../core/serder.ts';
 export declare class TraitCodex {
     EstOnly: string;
     DoNotDelegate: string;

package/dist/keri/app/habery.js

@@ -0,0 +1,117 @@
+import { Algos, Manager } from "../core/manager.js";
+import { MtrDex } from "../core/matter.js";
+import { Salter } from "../core/salter.js";
+import { incept } from "../core/eventing.js";
+export class TraitCodex {
+    constructor() {
+        this.EstOnly = 'EO'; // Only allow establishment events
+        this.DoNotDelegate = 'DND'; // Dot not allow delegated identifiers
+        this.NoBackers = 'NB'; // Do not allow backers
+    }
+}
+export const TraitDex = new TraitCodex();
+export class Hab {
+    constructor(name, icp) {
+        this.name = name;
+        this.serder = icp;
+    }
+    get pre() {
+        return this.serder.sad['i'];
+    }
+}
+export class Habery {
+    constructor({ name, passcode, seed, aeid, pidx, salt }) {
+        this._habs = new Map();
+        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() {
+        return this._mgr;
+    }
+    get habs() {
+        return Array.from(this._habs.values());
+    }
+    habByName(name) {
+        return this._habs.get(name);
+    }
+    makeHab(name, { 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, }) {
+        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();
+        if (estOnly) {
+            cnfg.push(TraitDex.EstOnly);
+        }
+        if (DnD) {
+            cnfg.push(TraitDex.DoNotDelegate);
+        }
+        const keys = Array.from(verfers, (verfer) => verfer.qb64);
+        const ndigs = Array.from(digers, (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() {
+        return this._name;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { SignifyClient } from './clienting';
+import { SignifyClient } from './clienting.ts';
 /**
  * Notifications
  */
@@ -28,7 +28,7 @@ export declare class Notifications {
      * Delete a notification
      * @async
      * @param {string} said SAID of the notification
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
     delete(said: string): Promise<void>;
 }

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

@@ -1,20 +1,15 @@
-import { SignifyClient } from './clienting';
-import { parseRangeHeaders } from '../core/httping';
-
+import { parseRangeHeaders } from "../core/httping.js";
 /**
  * Notifications
  */
 export class Notifications {
-    client: SignifyClient;
-
     /**
      * Notifications
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * List notifications
      * @async
@@ -22,18 +17,15 @@ export class Notifications {
      * @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> {
+    async list(start = 0, end = 24) {
         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,
@@ -41,29 +33,27 @@ export class Notifications {
             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> {
+    async mark(said) {
         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
+     * @returns {Promise<void>}
      */
-    async delete(said: string): Promise<void> {
+    async delete(said) {
         const path = `/notifications/` + said;
         const method = 'DELETE';
-        await this.client.fetch(path, method, null);
+        await this.client.fetch(path, method, undefined);
     }
 }

package/dist/keri/core/authing.d.ts

@@ -1,5 +1,5 @@
-import { Signer } from './signer';
-import { Verfer } from './verfer';
+import { Signer } from './signer.ts';
+import { Verfer } from './verfer.ts';
 export declare class Authenticater {
     static DefaultFields: string[];
     private _verfer;

package/{src/keri/core/authing.ts → dist/keri/core/authing.js}

@@ -1,26 +1,12 @@
-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';
+import { desiginput, HEADER_SIG_INPUT, HEADER_SIG_TIME, normalize, siginput, } from "./httping.js";
+import { Signage, signature, designature } from "../end/ending.js";
 export class Authenticater {
-    static DefaultFields = [
-        '@method',
-        '@path',
-        'signify-resource',
-        'signify-timestamp',
-    ];
-    private _verfer: Verfer;
-    private readonly _csig: Signer;
-
-    constructor(csig: Signer, verfer: Verfer) {
+    constructor(csig, verfer) {
         this._csig = csig;
         this._verfer = verfer;
     }
-
-    verify(headers: Headers, method: string, path: string): boolean {
-        const siginput = headers.get('Signature-Input');
+    verify(headers, method, path) {
+        const siginput = headers.get(HEADER_SIG_INPUT);
         if (siginput == null) {
             return false;
         }
@@ -34,23 +20,25 @@ export class Authenticater {
             return false;
         }
         inputs.forEach((input) => {
-            const items = new Array<string>();
-            input.fields!.forEach((field: string) => {
+            const items = new Array();
+            input.fields.forEach((field) => {
                 if (field.startsWith('@')) {
                     if (field == '@method') {
                         items.push(`"${field}": ${method}`);
-                    } else if (field == '@path') {
+                    }
+                    else if (field == '@path') {
                         items.push(`"${field}": ${path}`);
                     }
-                } else {
+                }
+                else {
                     if (headers.has(field)) {
-                        const value = normalize(headers.get(field) as string);
+                        const value = normalize(headers.get(field));
                         items.push(`"${field}": ${value}`);
                     }
                 }
             });
-            const values = new Array<string>();
-            values.push(`(${input.fields!.join(' ')})`);
+            const values = new Array();
+            values.push(`(${input.fields.join(' ')})`);
             values.push(`created=${input.created}`);
             if (input.expires != undefined) {
                 values.push(`expires=${input.expires}`);
@@ -70,26 +58,19 @@ export class Authenticater {
             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)) {
+            const signage = designature(signature);
+            const markers = signage[0].markers;
+            const cig = markers.get(input.name);
+            if (!cig || !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 {
+    sign(headers, method, path, fields) {
         if (fields == undefined) {
             fields = Authenticater.DefaultFields;
         }
-
         const [header, sig] = siginput(this._csig, {
             name: 'signify',
             method,
@@ -99,19 +80,22 @@ export class Authenticater {
             alg: 'ed25519',
             keyid: this._csig.verfer.qb64,
         });
-
         header.forEach((value, key) => {
             headers.append(key, value);
         });
-
-        const markers = new Map<string, Siger | Cigar>();
+        const markers = new Map();
         markers.set('signify', sig);
         const signage = new Signage(markers, false);
         const signed = signature([signage]);
         signed.forEach((value, key) => {
             headers.append(key, value);
         });
-
         return headers;
     }
 }
+Authenticater.DefaultFields = [
+    '@method',
+    '@path',
+    'signify-resource',
+    HEADER_SIG_TIME.toLowerCase(),
+];

package/dist/keri/core/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeBase64Url(input: Uint8Array): string;
+export declare function decodeBase64Url(input: string): Uint8Array;