signify-ts 0.1.0 → 0.1.1

package/src/keri/core/counter.ts

@@ -0,0 +1,207 @@
+import {Codex, Sizage} from "./matter";
+import {b, b64ToInt, d, intToB64} from "./core";
+
+export interface CounterArgs {
+    code?: string
+    count?: number
+    countB64?: string
+    qb64b?: Uint8Array,
+    qb64?: string
+    qb2?: Uint8Array
+    strip?: boolean
+}
+
+export class CounterCodex extends Codex {
+    public ControllerIdxSigs: string = '-A'  // Qualified Base64 Indexed Signature.
+    public WitnessIdxSigs: string = '-B'  // Qualified Base64 Indexed Signature.
+    public NonTransReceiptCouples: string = '-C'  // Composed Base64 Couple, pre+cig.
+    public TransReceiptQuadruples: string = '-D'  // Composed Base64 Quadruple, pre+snu+dig+sig.
+    public FirstSeenReplayCouples: string = '-E'  // Composed Base64 Couple, fnu+dts.
+    public TransIdxSigGroups: string = '-F'  // Composed Base64 Group, pre+snu+dig+ControllerIdxSigs group.
+    public SealSourceCouples: string = '-G'  // Composed Base64 couple, snu+dig of given delegators or issuers event
+    public TransLastIdxSigGroups: string = '-H'  // Composed Base64 Group, pre+ControllerIdxSigs group.
+    public SealSourceTriples: string = '-I'  // Composed Base64 triple, pre+snu+dig of anchoring source event
+    public SadPathSig: string = '-J'  // Composed Base64 Group path+TransIdxSigGroup of SAID of content
+    public SadPathSigGroup: string = '-K'  // Composed Base64 Group, root(path)+SaidPathCouples
+    public PathedMaterialQuadlets: string = '-L'  // Composed Grouped Pathed Material Quadlet (4 char each)
+    public AttachedMaterialQuadlets: string = '-V'  // Composed Grouped Attached Material Quadlet (4 char each)
+    public BigAttachedMaterialQuadlets: string = '-0V'  // Composed Grouped Attached Material Quadlet (4 char each)
+    public KERIProtocolStack: string = '--AAA'  // KERI ACDC Protocol Stack CESR Version
+}
+
+export const CtrDex = new CounterCodex()
+
+export class Counter {
+    static Sizes = new Map(Object.entries({
+        '-A': new Sizage(2, 2, 4, 0),
+        '-B': new Sizage(2, 2, 4, 0),
+        '-C': new Sizage(2, 2, 4, 0),
+        '-D': new Sizage(2, 2, 4, 0),
+        '-E': new Sizage(2, 2, 4, 0),
+        '-F': new Sizage(2, 2, 4, 0),
+        '-G': new Sizage(2, 2, 4, 0),
+        '-H': new Sizage(2, 2, 4, 0),
+        '-I': new Sizage(2, 2, 4, 0),
+        '-J': new Sizage(2, 2, 4, 0),
+        '-K': new Sizage(2, 2, 4, 0),
+        '-L': new Sizage(2, 2, 4, 0),
+        '-V': new Sizage(2, 2, 4, 0),
+        '-0V': new Sizage(3, 5, 8, 0),
+        '--AAA': new Sizage(5, 3, 8, 0),
+    }))
+
+    static Hards = new Map<string, number>([['-A', 2], ['-B', 2], ['-C', 2], ['-D', 2], ['-E', 2], ['-F', 2], ['-G', 2],
+        ['-H', 2], ['-I', 2], ['-J', 2], ['-K', 2], ['-L', 2], ['-M', 2], ['-N', 2], ['-O', 2], ['-P', 2], ['-Q', 2],
+        ['-R', 2], ['-S', 2], ['-T', 2], ['-U', 2], ['-V', 2], ['-W', 2], ['-X', 2], ['-Y', 2], ['-Z', 2], ['-a', 2],
+        ['-b', 2], ['-c', 2], ['-d', 2], ['-e', 2], ['-f', 2], ['-g', 2], ['-h', 2], ['-i', 2], ['-j', 2], ['-k', 2],
+        ['-l', 2], ['-m', 2], ['-n', 2], ['-o', 2], ['-p', 2], ['-q', 2], ['-r', 2], ['-s', 2], ['-t', 2], ['-u', 2],
+        ['-v', 2], ['-w', 2], ['-x', 2], ['-y', 2], ['-z', 2], ['-0', 3], ['--', 5]])
+
+    private _code: string = "";
+    private _count: number = -1;
+
+    constructor({code, count, countB64, qb64b, qb64, qb2}: CounterArgs) {
+        if (code != undefined) {
+            if (!Counter.Sizes.has(code)) {
+                throw new Error(`"Unsupported code=${code}.`)
+            }
+
+            let sizage = Counter.Sizes.get(code)!
+            let cs = sizage.hs + sizage.ss
+            if (sizage.fs != cs || cs % 4 != 0) {
+                throw new Error(`Whole code size not full size or not multiple of 4. cs=${cs} fs=${sizage.fs}.`)
+            }
+
+            if (count == undefined) {
+                count = countB64 == undefined ? 1 : b64ToInt(countB64)
+            }
+
+            if (count < 0 || count > (64 ** sizage.ss - 1)) {
+                throw new Error(`Invalid count=${count} for code=${code}.`)
+            }
+
+            this._code = code
+            this._count = count
+
+        } else if (qb64b != undefined) {
+            let qb64 = d(qb64b)
+            this._exfil(qb64)
+        } else if (qb64 != undefined) {
+            this._exfil(qb64)
+        } else if (qb2 != undefined) {
+
+        } else {
+            throw new Error(`Improper initialization need either (code and count) or qb64b or qb64 or qb2.`)
+        }
+    }
+
+    get code(): string {
+        return this._code;
+    }
+
+    get count() {
+        return this._count;
+    }
+
+    get qb64() {
+        return this._infil();
+    }
+
+    get qb64b() {
+        return b(this.qb64)
+    }
+
+    countToB64(l?: number): string {
+        if (l == undefined) {
+            let sizage = Counter.Sizes.get(this.code)!
+            l = sizage.ss
+        }
+        return intToB64(this.count, l)
+    }
+
+    static semVerToB64(version: string = "", major: number = 0, minor: number = 0, patch: number = 0): string {
+        let parts = [major, minor, patch]
+        if (version != "") {
+            let ssplits = version.split(".")
+            let splits = ssplits.map((x) => {
+                if (x == "") return 0
+                return parseInt(x)
+            })
+
+            let off = splits.length
+            let x = 3 - off
+            for (let i = 0; i < x; i++) {
+                splits.push(parts[i + off])
+            }
+            parts = splits
+        }
+
+        parts.forEach((p) => {
+            if(p < 0 || p > 63) {
+                throw new Error(`Out of bounds semantic version. Part=${p} is < 0 or > 63.`)
+            }
+        })
+
+        return parts.map((p) => {
+            return intToB64(p, 1)
+        }).join("")
+    }
+
+    private _infil(): string {
+        let code = this.code;
+        let count = this.count;
+
+        let sizage = Counter.Sizes.get(code)!;
+        let cs = sizage.hs + sizage.ss
+        if (sizage.fs != cs || cs % 4 != 0) {
+            throw new Error(`Whole code size not full size or not multiple of 4. cs=${cs} fs=${sizage.fs}.`)
+        }
+
+        if (count < 0 || count > (64 ** sizage.ss - 1)) {
+            throw new Error(`Invalid count=${count} for code=${code}.`)
+        }
+
+        let both = `${code}${intToB64(count, sizage.ss)}`
+
+        if (both.length % 4) {
+            throw new Error(`Invalid size = ${both.length} of ${both} not a multiple of 4.`)
+        }
+
+        return both
+    }
+
+    private _exfil(qb64: string) {
+        if (qb64.length == 0) {
+            throw new Error("Empty Material")
+        }
+
+        let first = qb64.slice(0, 2);
+        if (!Counter.Hards.has(first)) {
+            throw new Error(`Unexpected code ${first}`)
+        }
+
+        let hs = Counter.Hards.get(first)!;
+        if (qb64.length < hs) {
+            throw new Error(`Need ${hs - qb64.length} more characters.`)
+        }
+
+        let hard = qb64.slice(0, hs);
+        if (!Counter.Sizes.has(hard)) {
+            throw new Error(`Unsupported code ${hard}`)
+        }
+
+        let sizage = Counter.Sizes.get(hard)!;
+        let cs = sizage!.hs + sizage!.ss;
+
+        if (qb64.length < cs) {
+            throw new Error(`Need ${cs - qb64.length} more chars.`)
+        }
+
+        let scount = qb64.slice(sizage.hs, sizage.hs + sizage.ss)
+        let count = b64ToInt(scount)
+
+        this._code = hard
+        this._count = count
+    }
+
+}

package/src/keri/core/diger.ts

@@ -1,4 +1,5 @@
-const blake3 = require('blake3');
+import {createHash} from "blake3"
+
 import {Matter, MatterArgs, MtrDex} from './matter';
 
 /**
@@ -8,7 +9,6 @@ import {Matter, MatterArgs, MtrDex} from './matter';
  *
  */
 
-
 export class Diger extends Matter {
     private readonly _verify: any
 
@@ -16,13 +16,13 @@ export class Diger extends Matter {
     constructor({raw, code = MtrDex.Blake3_256, qb64, qb64b, qb2}: MatterArgs, ser: Uint8Array | null = null) {
         try {
             super({raw, code, qb64, qb64b, qb2});
-        } catch (error: any) {
+        } catch (error) {
             if (ser == null) {
                 throw error;
             }
 
             if (code === MtrDex.Blake3_256) {
-                const hasher = blake3.createHash();
+                const hasher = createHash();
                 const dig = hasher.update(ser).digest('');
                 super({raw: dig, code: code});
             } else {
@@ -75,7 +75,7 @@ export class Diger extends Matter {
 
 
     blake3_256(ser: Uint8Array, dig: any) {
-        const hasher = blake3.createHash();
+        const hasher = createHash();
         let digest = hasher.update(ser).digest('');
         return (digest.toString() === dig.toString());
     }

package/src/keri/core/eventing.ts

@@ -0,0 +1,219 @@
+import {b, concat, Dict, Ident, Ilks, Serials, versify, Version, Versionage} from "./core";
+import {Tholder} from "./tholder";
+import {PNumber} from "./number";
+import {Prefixer} from "./prefixer";
+import {Serder} from "./serder";
+import {MtrDex, NonTransDex} from "./matter";
+import {Saider} from "./saider";
+import {Siger} from "./siger";
+import {Cigar} from "./cigar";
+import {Counter, CtrDex} from "./counter";
+
+
+function ample(n: number, f?: number, 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
+
+        let 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)
+        let m1 = Math.ceil((n + f + 1) / 2)
+        let 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 interface InceptArgs {
+    keys: Array<string>,
+    isith?: number | string | Array<string>,
+    ndigs?: Array<string>,
+    nsith?: number | string | Array<string>,
+    toad?: number | string,
+    wits?: Array<string>,
+    cnfg?: Array<string>,
+    data?: Array<object>,
+    version?: Version,
+    kind?: Serials,
+    code?: string,
+    intive?: boolean
+    delpre?: string
+}
+
+export function incept({keys, isith, ndigs, nsith, toad, wits, cnfg, data, version=Versionage, kind=Serials.JSON, code,
+                       intive = false, delpre}: InceptArgs) {
+
+
+    let vs = versify(Ident.KERI, version, kind, 0)
+    let ilk = delpre == undefined ? Ilks.icp : Ilks.dip
+    let sner = new PNumber(0)
+
+    if (isith == undefined) {
+        isith = Math.max(1, Math.ceil(keys.length / 2))
+    }
+
+    let tholder = new Tholder(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<string>()
+    }
+
+    if (nsith == undefined) {
+        nsith = Math.max(0, Math.ceil(ndigs.length / 2))
+    }
+
+    let ntholder = new Tholder(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)
+        }
+    }
+
+    let toader = new PNumber(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<string>() : cnfg
+    data = data == undefined ? new Array<object>() : data
+
+    let ked = {
+        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
+    } as Dict<any>
+
+    if (delpre != undefined) {
+        ked["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}, ked)
+        if (delpre != undefined) {
+            if(!prefixer.digestive) {
+                throw new Error(`Invalid derivation code = ${prefixer.code} for delegation. Must be digestive`)
+            }
+        }
+    }
+
+    ked["i"] = prefixer.qb64
+    if (prefixer.digestive) {
+        ked["d"] = prefixer.qb64
+    }
+    else {
+        [, ked] = Saider.saidify(ked)
+    }
+
+    return new Serder(ked)
+}
+
+export function messagize(serder: Serder, sigers?: Array<Siger>, seal?: any, wigers?:Array<Cigar>, cigars?:Array<Cigar>,
+                          pipelined:boolean = false): Uint8Array {
+    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.ked}.`)
+    }
+
+    if (sigers != undefined) {
+        if (seal != undefined) {
+            throw new Error(`Index sig group seals not yet supported`)
+        }
+
+        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
+}

package/src/keri/core/httping.ts

@@ -0,0 +1,163 @@
+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) {
+    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] {
+
+    let items = new Array<string>()
+    let ifields = new Array<[string, Map<string, string>]>()
+
+    fields.forEach((field) => {
+        if  (field.startsWith("@")) {
+            switch (field) {
+                case "@method":
+                    items.push(`"${field}": ${method}`)
+                    ifields.push([field, new Map()])
+                    break
+                case "@path":
+                    items.push(`"${field}": ${path}`)
+                    ifields.push([field, new Map()])
+                    break
+            }
+        } else {
+            if (!headers.has(field))
+                return
+
+            ifields.push([field, new Map()])
+            let value = normalize(headers.get(field)!)
+            items.push(`"${field}": ${value}`)
+        }
+    })
+
+    let nameParams = new Map<string, string|number>()
+    let now = Math.floor(nowUTC().getTime() / 1000)
+    nameParams.set("created", now)
+
+    let values = [`(${ifields.join(" ")})`, `created=${now}`]
+    if (expires != undefined) {
+        values.push(`expires=${expires}`)
+        nameParams.set('expires', expires)
+    }
+    if (nonce != undefined) {
+        values.push(`nonce=${nonce}`)
+        nameParams.set('nonce', nonce)
+    }
+    if (keyid != undefined) {
+        values.push(`keyid=${keyid}`)
+        nameParams.set('keyid', keyid)
+    }
+    if (context != undefined) {
+        values.push(`context=${context}`)
+        nameParams.set('context', context)
+    }
+    if (alg != undefined) {
+        values.push(`alg=${alg}`)
+        nameParams.set('alg', alg)
+    }
+    let sid = new Map([
+        [name, [ifields, nameParams]]
+    ])
+
+    let params = values.join(";")
+    items.push(`"@signature-params: ${params}"`)
+
+    let ser = items.join("\n")
+    let sig = signer.sign(b(ser))
+
+    return [new Map<string, string>([['Signature-Input', `${serializeDictionary(sid as Dictionary)}`]]), sig]
+}
+
+export class Unqualified {
+    private readonly _raw: Uint8Array
+
+    constructor(raw: Uint8Array) {
+        this._raw = raw
+    }
+
+    get qb64(): string {
+        return Base64.encode(Buffer.from(this._raw))
+    }
+
+    get qb64b(): Uint8Array {
+        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> {
+    let sid = parseDictionary(value)
+    let siginputs = new Array<Inputage>()
+
+    sid.forEach((value, key) => {
+        let siginput = new Inputage()
+        siginput.name = key
+        let list: Item[]
+        let params
+        [list, params] = value as [Item[], Parameters]
+        siginput.fields = list.map((item) => item[0])
+
+        if (!params.has("created")) {
+            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
+
+}

package/src/keri/core/indexer.ts

@@ -1,6 +1,7 @@
 import {EmptyMaterialError} from "./kering";
 import {b, b64ToInt, d, intToB64, readInt} from "./core";
-const Base64 = require('urlsafe-base64');
+import Base64 from "urlsafe-base64"
+import { Buffer } from 'buffer';
 
 export class IndexerCodex {
     Ed25519_Sig: string = 'A'  // Ed25519 sig appears same in both lists if any.

package/src/keri/core/keeping.ts

@@ -1,5 +1,4 @@
 export {};
-const { SigMat } = require('./sigmat');
 
 class Keeper {
     constructor() {