signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/dist/keri/core/eventing.js

@@ -0,0 +1,383 @@
+import { b, concat, Protocols, Ilks, Serials, versify, Vrsn_1_0, } from "./core.js";
+import { Tholder } from "./tholder.js";
+import { CesrNumber } from "./number.js";
+import { Prefixer } from "./prefixer.js";
+import { Serder } from "./serder.js";
+import { MtrDex, NonTransDex } from "./matter.js";
+import { Saider } from "./saider.js";
+import { Counter, CtrDex } from "./counter.js";
+import { Seqner } from "./seqner.js";
+const MaxIntThold = 2 ** 32 - 1;
+export function rotate({ pre = undefined, keys, dig = undefined, ilk = Ilks.rot, sn = 1, isith = undefined, ndigs = undefined, nsith = undefined, wits = undefined, cuts = [], adds = [], toad = undefined, data = undefined, version = undefined, kind = undefined, intive = true, }) {
+    const vs = versify(Protocols.KERI, version, kind, 0);
+    const _ilk = ilk;
+    if (_ilk != Ilks.rot && _ilk != Ilks.drt) {
+        throw new Error(`Invalid ilk = ${ilk} for rot or drt.`);
+    }
+    const sner = new CesrNumber({}, sn);
+    if (sner.num < 1) {
+        throw new Error(`Invalid sn = 0x${sner.numh} for rot or drt.`);
+    }
+    let _isit;
+    if (isith == undefined) {
+        _isit = Math.max(1, Math.ceil(keys.length / 2));
+    }
+    else {
+        _isit = isith; // TODO this type as number does not make sense when isith is a string containing weighted thresholds
+    }
+    const tholder = new Tholder({ sith: _isit });
+    if (tholder.num != undefined && tholder.num < 1) {
+        throw new Error(`Invalid sith = ${tholder.num} less than 1.`);
+    }
+    if (tholder.size > keys.length) {
+        // TODO this error should say that the threshold has not been met
+        throw new Error(`Invalid sith = ${tholder.num} for keys = ${keys}`);
+    }
+    let _ndigs;
+    if (ndigs === undefined) {
+        _ndigs = [];
+    }
+    else {
+        _ndigs = ndigs;
+    }
+    let _nsith;
+    if (nsith === undefined) {
+        _nsith = Math.max(1, Math.ceil(_ndigs.length / 2));
+    }
+    else {
+        _nsith = nsith;
+    }
+    const ntholder = new Tholder({ sith: _nsith });
+    if (ntholder.num != undefined && ntholder.num < 1) {
+        throw new Error(`Invalid sith = ${ntholder.num} less than 1.`);
+    }
+    if (ntholder.size > _ndigs.length) {
+        // TODO this error should say that the threshold has not been met
+        throw new Error(`Signing threshold failure: ${keys.length} number of signers not equal to or greater than sith = ${tholder.size} for keys = ${keys}`);
+    }
+    let _wits;
+    if (wits === undefined) {
+        _wits = [];
+    }
+    else {
+        _wits = wits;
+    }
+    const witset = new Set(_wits);
+    if (witset.size != _wits.length) {
+        throw new Error(`Invalid wits = ${wits}, has duplicates.`);
+    }
+    const cutset = new Set(cuts);
+    if (cutset.size != cuts.length) {
+        throw new Error(`Invalid cuts = ${cuts}, has duplicates.`);
+    }
+    const addset = new Set(adds);
+    if (addset.size != adds.length) {
+        throw new Error(`Invalid adds = ${adds}, has duplicates.`);
+    }
+    //non empty intersection of witset and addset
+    const witaddset = new Set([...witset].filter((x) => addset.has(x)));
+    if (witaddset.size > 0) {
+        throw new Error(`Invalid member combination among wits = ${wits}, and adds = ${adds}.`);
+    }
+    // non empty intersection of cutset and addset
+    const cutaddset = new Set([...cutset].filter((x) => addset.has(x)));
+    if (cutaddset.size > 0) {
+        throw new Error(`Invalid member combination among cuts = ${cuts}, and adds = ${adds}.`);
+    }
+    const newitsetdiff = new Set(_wits);
+    cuts.forEach(function (v) {
+        newitsetdiff.delete(v);
+    });
+    const newitset = new Set((function* () {
+        yield* newitsetdiff;
+        yield* addset;
+    })());
+    if (newitset.size != witset.size - cutset.size + addset.size) {
+        throw new Error(`Invalid member combination among wits = ${wits}, cuts = ${cuts}, and adds = ${adds}.`);
+    }
+    let _toad;
+    if (toad === undefined) {
+        if (newitset.size == 0) {
+            _toad = 0;
+        }
+        else {
+            _toad = ample(newitset.size);
+        }
+    }
+    else {
+        _toad = toad;
+    }
+    if (newitset.size > 0) {
+        if (_toad < 1 || _toad > newitset.size) {
+            throw new Error(`Invalid toad = ${_toad} for wit = ${wits}`);
+        }
+    }
+    else {
+        if (_toad != 0) {
+            throw new Error(`Invalid toad = ${_toad} for wit = ${wits}`);
+        }
+    }
+    const _sad = {
+        v: vs,
+        t: _ilk,
+        d: '',
+        i: pre,
+        s: sner.numh,
+        p: dig,
+        kt: tholder.num &&
+            intive &&
+            tholder.num !== undefined &&
+            tholder.num <= MaxIntThold
+            ? tholder.num.toString(16)
+            : tholder.sith,
+        k: keys,
+        nt: ntholder.num &&
+            intive &&
+            ntholder.num !== undefined &&
+            ntholder.num <= MaxIntThold
+            ? ntholder.num.toString(16)
+            : ntholder.sith,
+        n: _ndigs,
+        bt: _toad && intive && _toad !== undefined && _toad <= MaxIntThold
+            ? _toad
+            : _toad.toString(16),
+        br: cuts,
+        ba: adds,
+        a: data != undefined ? data : [],
+    };
+    const [, sad] = Saider.saidify(_sad);
+    return new Serder(sad);
+}
+export function ample(n, f, weak = true) {
+    n = Math.max(0, n); // no negatives
+    let f1;
+    if (f == undefined) {
+        f1 = Math.max(1, Math.floor(Math.max(0, n - 1) / 3)); // least floor f subject to n >= 3*f+1
+        const f2 = Math.max(1, Math.ceil(Math.max(0, n - 1) / 3)); // most Math.ceil f subject to n >= 3*f+1
+        if (weak) {
+            // try both fs to see which one has lowest m
+            return Math.min(n, Math.ceil((n + f1 + 1) / 2), Math.ceil((n + f2 + 1) / 2));
+        }
+        else {
+            return Math.min(n, Math.max(0, n - f1, Math.ceil((n + f1 + 1) / 2)));
+        }
+    }
+    else {
+        f = Math.max(0, f);
+        const m1 = Math.ceil((n + f + 1) / 2);
+        const m2 = Math.max(0, n - f);
+        if (m2 < m1 && n > 0) {
+            throw new Error(`Invalid f=${f} is too big for n=${n}.`);
+        }
+        if (weak) {
+            return Math.min(n, m1, m2);
+        }
+        else {
+            return Math.min(n, Math.max(m1, m2));
+        }
+    }
+}
+export function incept({ keys, isith, ndigs, nsith, toad, wits, cnfg, data, version = Vrsn_1_0, kind = Serials.JSON, code, intive = false, delpre, }) {
+    const vs = versify(Protocols.KERI, version, kind, 0);
+    const ilk = delpre == undefined ? Ilks.icp : Ilks.dip;
+    const sner = new CesrNumber({}, 0);
+    if (isith == undefined) {
+        isith = Math.max(1, Math.ceil(keys.length / 2));
+    }
+    const tholder = new Tholder({ sith: isith });
+    if (tholder.num != undefined && tholder.num < 1) {
+        throw new Error(`Invalid sith = ${tholder.num} less than 1.`);
+    }
+    if (tholder.size > keys.length) {
+        throw new Error(`Invalid sith = ${tholder.num} for keys ${keys}`);
+    }
+    if (ndigs == undefined) {
+        ndigs = new Array();
+    }
+    if (nsith == undefined) {
+        nsith = Math.max(0, Math.ceil(ndigs.length / 2));
+    }
+    const ntholder = new Tholder({ sith: nsith });
+    if (ntholder.num != undefined && ntholder.num < 0) {
+        throw new Error(`Invalid nsith = ${ntholder.num} less than 0.`);
+    }
+    if (ntholder.size > keys.length) {
+        throw new Error(`Invalid nsith = ${ntholder.num} for keys ${ndigs}`);
+    }
+    wits = wits == undefined ? [] : wits;
+    if (new Set(wits).size != wits.length) {
+        throw new Error(`Invalid wits = ${wits}, has duplicates.`);
+    }
+    if (toad == undefined) {
+        if (wits.length == 0) {
+            toad = 0;
+        }
+        else {
+            toad = ample(wits.length);
+        }
+    }
+    const toader = new CesrNumber({}, toad);
+    if (wits.length > 0) {
+        if (toader.num < 1 || toader.num > wits.length) {
+            throw new Error(`Invalid toad = ${toader.num} for wits = ${wits}`);
+        }
+    }
+    else {
+        if (toader.num != 0) {
+            throw new Error(`Invalid toad = ${toader.num} for wits = ${wits}`);
+        }
+    }
+    cnfg = cnfg == undefined ? new Array() : cnfg;
+    data = data == undefined ? new Array() : data;
+    let sad = {
+        v: vs,
+        t: ilk,
+        d: '',
+        i: '',
+        s: sner.numh,
+        kt: intive && tholder.num != undefined ? tholder.num : tholder.sith,
+        k: keys,
+        nt: intive && tholder.num != undefined ? ntholder.num : ntholder.sith,
+        n: ndigs,
+        bt: intive ? toader.num : toader.numh,
+        b: wits,
+        c: cnfg,
+        a: data,
+    };
+    if (delpre != undefined) {
+        sad['di'] = delpre;
+        if (code == undefined) {
+            code = MtrDex.Blake3_256;
+        }
+    }
+    let prefixer;
+    if (delpre == undefined && code == undefined && keys.length == 1) {
+        prefixer = new Prefixer({ qb64: keys[0] });
+        if (prefixer.digestive) {
+            throw new Error(`Invalid code, digestive=${prefixer.code}, must be derived from ked.`);
+        }
+    }
+    else {
+        prefixer = new Prefixer({ code: code }, sad);
+        if (delpre != undefined) {
+            if (!prefixer.digestive) {
+                throw new Error(`Invalid derivation code = ${prefixer.code} for delegation. Must be digestive`);
+            }
+        }
+    }
+    sad['i'] = prefixer.qb64;
+    if (prefixer.digestive) {
+        sad['d'] = prefixer.qb64;
+    }
+    else {
+        [, sad] = Saider.saidify(sad);
+    }
+    return new Serder(sad);
+}
+export function messagize(serder, sigers, seal, wigers, cigars, pipelined = false) {
+    let msg = new Uint8Array(b(serder.raw));
+    let atc = new Uint8Array();
+    if (sigers == undefined && wigers == undefined && cigars == undefined) {
+        throw new Error(`Missing attached signatures on message = ${serder.sad}.`);
+    }
+    if (sigers != undefined) {
+        if (seal != undefined) {
+            if (seal[0] == 'SealEvent') {
+                atc = concat(atc, new Counter({ code: CtrDex.TransIdxSigGroups, count: 1 })
+                    .qb64b);
+                atc = concat(atc, new TextEncoder().encode(seal[1].i));
+                atc = concat(atc, new Seqner({ sn: parseInt(seal[1].s) }).qb64b);
+                atc = concat(atc, new TextEncoder().encode(seal[1].d));
+            }
+            else if (seal[0] == 'SealLast') {
+                atc = concat(atc, new Counter({
+                    code: CtrDex.TransLastIdxSigGroups,
+                    count: 1,
+                }).qb64b);
+                atc = concat(atc, new TextEncoder().encode(seal[1].i));
+            }
+        }
+        atc = concat(atc, new Counter({
+            code: CtrDex.ControllerIdxSigs,
+            count: sigers.length,
+        }).qb64b);
+        sigers.forEach((siger) => {
+            atc = concat(atc, siger.qb64b);
+        });
+    }
+    if (wigers != undefined) {
+        atc = concat(atc, new Counter({
+            code: CtrDex.ControllerIdxSigs,
+            count: wigers.length,
+        }).qb64b);
+        wigers.forEach((wiger) => {
+            if (wiger.verfer && !(wiger.verfer.code in NonTransDex)) {
+                throw new Error(`Attempt to use tranferable prefix=${wiger.verfer.qb64} for receipt.`);
+            }
+            atc = concat(atc, wiger.qb64b);
+        });
+    }
+    if (cigars != undefined) {
+        atc = concat(atc, new Counter({
+            code: CtrDex.ControllerIdxSigs,
+            count: cigars.length,
+        }).qb64b);
+        cigars.forEach((cigar) => {
+            if (cigar.verfer && !(cigar.verfer.code in NonTransDex)) {
+                throw new Error(`Attempt to use tranferable prefix=${cigar.verfer.qb64} for receipt.`);
+            }
+            atc = concat(atc, cigar.qb64b);
+        });
+    }
+    if (pipelined) {
+        if (atc.length % 4 != 0) {
+            throw new Error(`Invalid attachments size=${atc.length}, nonintegral quadlets.`);
+        }
+        msg = concat(msg, new Counter({
+            code: CtrDex.AttachedMaterialQuadlets,
+            count: Math.floor(atc.length / 4),
+        }).qb64b);
+    }
+    msg = concat(msg, atc);
+    return msg;
+}
+export function interact(args) {
+    let { pre, dig, sn, data, version, kind } = args;
+    const vs = versify(Protocols.KERI, version, kind, 0);
+    const ilk = Ilks.ixn;
+    const sner = new CesrNumber({}, sn);
+    if (sner.num < 1) {
+        throw new Error(`Invalid sn = 0x${sner.numh} for ixn.`);
+    }
+    data = data == undefined ? new Array() : data;
+    let sad = {
+        v: vs,
+        t: ilk,
+        d: '',
+        i: pre,
+        s: sner.numh,
+        p: dig,
+        a: data,
+    };
+    [, sad] = Saider.saidify(sad);
+    return new Serder(sad);
+}
+export function reply(route = '', data, stamp, version, kind = Serials.JSON) {
+    const vs = versify(Protocols.KERI, version, kind, 0);
+    if (data == undefined) {
+        data = {};
+    }
+    const _sad = {
+        v: vs,
+        t: Ilks.rpy,
+        d: '',
+        dt: stamp !== null && stamp !== void 0 ? stamp : new Date().toISOString().replace('Z', '000+00:00'),
+        r: route,
+        a: data,
+    };
+    const [, sad] = Saider.saidify(_sad);
+    const saider = new Saider({ qb64: sad['d'] });
+    if (!saider.verify(sad, true, true, kind, 'd'))
+        throw new Error(`Invalid said = ${saider.qb64} for reply msg=${sad}.`);
+    return new Serder(sad);
+}

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

@@ -1,6 +1,8 @@
-import { Signer } from './signer';
-import { Cigar } from './cigar';
-import { Siger } from './siger';
+import { Signer } from './signer.ts';
+import { Cigar } from './cigar.ts';
+import { Siger } from './siger.ts';
+export declare const HEADER_SIG_INPUT: string;
+export declare const HEADER_SIG_TIME: string;
 export declare function normalize(header: string): string;
 export interface SiginputArgs {
     name: string;
@@ -14,7 +16,12 @@ export interface SiginputArgs {
     keyid?: string;
     context?: string;
 }
-export declare function siginput(signer: Signer, { name, method, path, headers, fields, expires, nonce, alg, keyid, context, }: SiginputArgs): [Map<string, string>, Siger | Cigar];
+/**
+ * Generates, serializes, and signs a Signature-Input HTTP header value as a structured header
+ * @param signer
+ * @param sigInputArgs
+ */
+export declare function siginput(signer: Signer, sigInputArgs: SiginputArgs): [Map<string, string>, Siger | Cigar];
 export declare class Unqualified {
     private readonly _raw;
     constructor(raw: Uint8Array);

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

@@ -1,53 +1,21 @@
-import {
-    serializeDictionary,
-    Dictionary,
-    parseDictionary,
-    Item,
-    Parameters,
-} from 'structured-headers';
-import { Signer } from './signer';
-import { b } from './core';
-import { Cigar } from './cigar';
-import { nowUTC } from './utils';
-import { Siger } from './siger';
-import Base64 from 'urlsafe-base64';
-import { Buffer } from 'buffer';
-
-export function normalize(header: string) {
+import { serializeDictionary, parseDictionary, } from 'structured-headers';
+import { b } from "./core.js";
+import { nowUTC } from "./utils.js";
+import { encodeBase64Url } from "./base64.js";
+export const HEADER_SIG_INPUT = normalize('Signature-Input');
+export const HEADER_SIG_TIME = normalize('Signify-Timestamp');
+export function normalize(header) {
     return header.trim();
 }
-
-export interface SiginputArgs {
-    name: string;
-    method: string;
-    path: string;
-    headers: Headers;
-    fields: Array<string>;
-    expires?: number;
-    nonce?: string;
-    alg?: string;
-    keyid?: string;
-    context?: string;
-}
-
-export function siginput(
-    signer: Signer,
-    {
-        name,
-        method,
-        path,
-        headers,
-        fields,
-        expires,
-        nonce,
-        alg,
-        keyid,
-        context,
-    }: SiginputArgs
-): [Map<string, string>, Siger | Cigar] {
-    const items = new Array<string>();
-    const ifields = new Array<[string, Map<string, string>]>();
-
+/**
+ * Generates, serializes, and signs a Signature-Input HTTP header value as a structured header
+ * @param signer
+ * @param sigInputArgs
+ */
+export function siginput(signer, sigInputArgs) {
+    const { name, method, path, headers, fields, expires, nonce, alg, keyid, context, } = sigInputArgs;
+    const items = new Array();
+    const ifields = new Array();
     fields.forEach((field) => {
         if (field.startsWith('@')) {
             switch (field) {
@@ -60,19 +28,18 @@ export function siginput(
                     ifields.push([field, new Map()]);
                     break;
             }
-        } else {
-            if (!headers.has(field)) return;
-
+        }
+        else {
+            if (!headers.has(field))
+                return;
             ifields.push([field, new Map()]);
-            const value = normalize(headers.get(field)!);
+            const value = normalize(headers.get(field));
             items.push(`"${field}": ${value}`);
         }
     });
-
-    const nameParams = new Map<string, string | number>();
+    const nameParams = new Map();
     const now = Math.floor(nowUTC().getTime() / 1000);
     nameParams.set('created', now);
-
     const values = [
         `(${ifields.map((field) => field[0]).join(' ')})`,
         `created=${now}`,
@@ -98,90 +65,61 @@ export function siginput(
         nameParams.set('alg', alg);
     }
     const sid = new Map([[name, [ifields, nameParams]]]);
-
     const params = values.join(';');
     items.push(`"@signature-params: ${params}"`);
-
     const ser = items.join('\n');
     const sig = signer.sign(b(ser));
-
     return [
-        new Map<string, string>([
-            ['Signature-Input', `${serializeDictionary(sid as Dictionary)}`],
+        new Map([
+            [HEADER_SIG_INPUT, `${serializeDictionary(sid)}`],
         ]),
         sig,
     ];
 }
-
 export class Unqualified {
-    private readonly _raw: Uint8Array;
-
-    constructor(raw: Uint8Array) {
+    constructor(raw) {
         this._raw = raw;
     }
-
-    get qb64(): string {
-        return Base64.encode(Buffer.from(this._raw));
+    get qb64() {
+        return encodeBase64Url(this._raw);
     }
-
-    get qb64b(): Uint8Array {
+    get qb64b() {
         return b(this.qb64);
     }
 }
-
 export class Inputage {
-    public name: any;
-    public fields: any;
-    public created: any;
-    public expires: any;
-    public nonce: any;
-    public alg: any;
-    public keyid: any;
-    public context: any;
 }
-
-export function desiginput(value: string): Array<Inputage> {
+export function desiginput(value) {
     const sid = parseDictionary(value);
-    const siginputs = new Array<Inputage>();
-
+    const siginputs = new Array();
     sid.forEach((value, key) => {
         const siginput = new Inputage();
         siginput.name = key;
-        let list: Item[];
+        let list;
         let params;
-        [list, params] = value as [Item[], Parameters];
+        [list, params] = value;
         siginput.fields = list.map((item) => item[0]);
-
         if (!params.has('created')) {
-            throw new Error(
-                'missing required `created` field from signature input'
-            );
+            throw new Error('missing required `created` field from signature input');
         }
         siginput.created = params.get('created');
-
         if (params.has('expires')) {
             siginput.expires = params.get('expires');
         }
-
         if (params.has('nonce')) {
             siginput.nonce = params.get('nonce');
         }
-
         if (params.has('alg')) {
             siginput.alg = params.get('alg');
         }
-
         if (params.has('keyid')) {
             siginput.keyid = params.get('keyid');
         }
-
         if (params.has('context')) {
             siginput.context = params.get('context');
         }
-
         siginputs.push(siginput);
     });
-
     return siginputs;
 }
 /** Parse start, end and total from HTTP Content-Range header value
@@ -189,21 +127,18 @@ export function desiginput(value: string): Array<Inputage> {
  * @param {string} typ - type of range, e.g. "aids"
  * @returns {start: number, end: number, total: number} - object with start, end and total properties
  */
-export function parseRangeHeaders(
-    header: string | null,
-    typ: string
-): { start: number; end: number; total: number } {
+export function parseRangeHeaders(header, typ) {
     if (header !== null) {
         const data = header.replace(`${typ} `, '');
         const values = data.split('/');
         const rng = values[0].split('-');
-
         return {
             start: parseInt(rng[0]),
             end: parseInt(rng[1]),
             total: parseInt(values[1]),
         };
-    } else {
+    }
+    else {
         return { start: 0, end: 0, total: 0 };
     }
 }

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

@@ -92,7 +92,7 @@ export declare class Indexer {
     get index(): number;
     get ondex(): number | undefined;
     get qb64(): string;
-    get qb64b(): Uint8Array;
+    get qb64b(): Uint8Array<ArrayBufferLike>;
     private _infil;
     _exfil(qb64: string): void;
 }