signify-ts 0.1.0 → 0.2.0

package/src/keri/core/tholder.ts

@@ -0,0 +1,218 @@
+import { BexDex, Matter, NumDex } from './matter';
+import { CesrNumber } from './number';
+import { Fraction } from 'mathjs';
+import { math } from '../../index';
+
+export class Tholder {
+    private _weighted: boolean = false;
+    private _thold: any = undefined;
+    private _size: number = 0;
+    private _number: CesrNumber | undefined = undefined;
+    private _satisfy: any = undefined;
+
+    // private _bexter: any
+
+    constructor(kargs: { thold?: any; limen?: any; sith?: any }) {
+        if (kargs.thold !== undefined) {
+            this._processThold(kargs.thold);
+        } else if (kargs.limen != undefined) {
+            this._processLimen(kargs.limen);
+        } else if (kargs.sith !== undefined) {
+            this._processSith(kargs.sith);
+        } else {
+            throw new Error('Missing threshold expression');
+        }
+    }
+
+    get weighted(): boolean {
+        return this._weighted;
+    }
+
+    get thold(): any {
+        return this._thold;
+    }
+
+    get size(): number {
+        return this._size;
+    }
+
+    get limen(): any {
+        return this._number?.qb64b;
+    }
+
+    get sith(): string {
+        if (this.weighted) {
+            let sith = this.thold.map((clause: Fraction[]) => {
+                return clause.map((c) => {
+                    if (0 < Number(c) && Number(c) < 1) {
+                        return math.format(c, { fraction: 'ratio' });
+                    } else {
+                        return math.format(c, { fraction: 'decimal' });
+                    }
+                });
+            });
+            if (sith.length == 1) {
+                sith = sith[0];
+            }
+
+            return sith;
+        } else {
+            return this.thold.toString(16);
+        }
+    }
+
+    get json(): string {
+        return JSON.stringify(this.sith);
+    }
+
+    get num(): number | undefined {
+        return this._weighted ? undefined : this._thold;
+    }
+
+    private _processThold(thold: number | Array<Array<Fraction>>) {
+        if (typeof thold === 'number') {
+            this._processUnweighted(thold);
+        } else {
+            this._processWeighted(thold);
+        }
+    }
+
+    private _processLimen(limen: string) {
+        const matter = new Matter({ qb64: limen });
+        if (NumDex.has(matter.code)) {
+            const number = new CesrNumber({
+                raw: matter.raw,
+                code: matter.code,
+            });
+            this._processUnweighted(number.num);
+        } else if (BexDex.has(matter.code)) {
+            // TODO: Implement Bexter
+        } else {
+            throw new Error('Invalid code for limen=' + matter.code);
+        }
+    }
+
+    private _processSith(sith: string | number | Array<string>) {
+        if (typeof sith == 'number') {
+            this._processUnweighted(sith);
+        } else if (typeof sith == 'string' && sith.indexOf('[') == -1) {
+            this._processUnweighted(parseInt(sith, 16));
+        } else {
+            let _sith: any = sith;
+            if (typeof sith == 'string') {
+                _sith = JSON.parse(sith);
+            }
+
+            if (_sith.length == 0) {
+                throw new Error('Empty weight list');
+            }
+
+            const mask = _sith.map((x: any) => {
+                return typeof x !== 'string';
+            });
+
+            if (mask.length > 0 && !mask.every((x: boolean) => x)) {
+                _sith = [_sith];
+            }
+
+            for (const c of _sith) {
+                const mask = c.map((x: any) => {
+                    return typeof x === 'string';
+                });
+                if (mask.length > 0 && !mask.every((x: boolean) => x)) {
+                    throw new Error(
+                        'Invalid sith, some weights in clause ' +
+                            mask +
+                            ' are non string'
+                    );
+                }
+            }
+
+            const thold = this._processClauses(_sith);
+            this._processWeighted(thold);
+        }
+    }
+
+    private _processClauses(sith: Array<Array<string>>): Fraction[][] {
+        const thold = new Array<Array<Fraction>>();
+        sith.forEach((clause) => {
+            thold.push(
+                clause.map((w) => {
+                    return this.weight(w);
+                })
+            );
+        });
+        return thold;
+    }
+
+    private _processUnweighted(thold: number) {
+        if (thold < 0) {
+            throw new Error('Non-positive int threshold = {thold}.');
+        }
+        this._thold = thold;
+        this._weighted = false;
+        this._size = this._thold; // used to verify that keys list size is at least size
+        this._satisfy = this._satisfy_numeric;
+        this._number = new CesrNumber({}, thold);
+        // this._bexter = undefined
+    }
+
+    private _processWeighted(thold: Array<Array<Fraction>>) {
+        for (const clause of thold) {
+            if (Number(math.sum(clause)) < 1) {
+                throw new Error(
+                    'Invalid sith clause: ' +
+                        thold +
+                        'all clause weight sums must be >= 1'
+                );
+            }
+        }
+
+        this._thold = thold;
+        this._weighted = true;
+        this._size = thold.reduce((acc, currentValue) => {
+            return acc + currentValue.length;
+        }, 0);
+        this._satisfy = this._satisfy_weighted;
+        //TODO: created Bexter if needed
+    }
+
+    private weight(w: string): Fraction {
+        return math.fraction(w);
+    }
+
+    private _satisfy_numeric(indices: any[]) {
+        return this.thold > 0 && indices.length >= this.thold; // at least one
+    }
+
+    private _satisfy_weighted(indices: any) {
+        if (indices.length === 0) {
+            return false;
+        }
+
+        const indexes: Set<number> = new Set(indices.sort());
+        const sats = new Array(indices.length).fill(false);
+        for (const idx of indexes) {
+            sats[idx] = true;
+        }
+        let wio = 0;
+        for (const clause of this.thold) {
+            let cw = 0;
+            for (const w of clause) {
+                if (sats[wio]) {
+                    cw += Number(w);
+                }
+                wio += 1;
+            }
+            if (cw < 1) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public satisfy(indices: any): boolean {
+        return this._satisfy(indices);
+    }
+}

package/src/keri/core/utils.ts

@@ -1,6 +1,12 @@
+import { Counter, CtrDex } from './counter';
+import { Seqner } from './seqner';
+import { Prefixer } from './prefixer';
+import { Saider } from './saider';
+import { Serder } from './serder';
+import { b } from './core';
 
 export function pad(n: any, width = 3, z = 0) {
-  return (String(z).repeat(width) + String(n)).slice(String(n).length);
+    return (String(z).repeat(width) + String(n)).slice(String(n).length);
 }
 
 /**
@@ -11,19 +17,19 @@ export function pad(n: any, width = 3, z = 0) {
  * @param {*} labels    labels is list of element labels in ked from which to extract values
  */
 export function extractValues(ked: any, labels: any) {
-  let values = [];
-  for (let label of labels) {
-    values = extractElementValues(ked[label], values);
-  }
+    let values = [];
+    for (const label of labels) {
+        values = extractElementValues(ked[label], values);
+    }
 
-  return values;
+    return values;
 }
 
 export function arrayEquals(ar1: Uint8Array, ar2: Uint8Array) {
-  return (
-      ar1.length === ar2.length &&
-      ar1.every((val, index) => val === ar2[index])
-  );
+    return (
+        ar1.length === ar2.length &&
+        ar1.every((val, index) => val === ar2[index])
+    );
 }
 
 /**
@@ -36,27 +42,22 @@ export function arrayEquals(ar1: Uint8Array, ar2: Uint8Array) {
  */
 
 function extractElementValues(element: any, values: any) {
-  let data = [];
-
-
-  try {
-    if((element instanceof Array) && !(typeof(element) == 'string')) {
-      for(let k in element)
-        extractElementValues(element[k], values);
-    } else if (typeof(element) == 'string') {
-      values.push(element);
+    let data = [];
+
+    try {
+        if (element instanceof Array && !(typeof element == 'string')) {
+            for (const k in element) extractElementValues(element[k], values);
+        } else if (typeof element == 'string') {
+            values.push(element);
+        }
+        data = values;
+    } catch (error) {
+        throw new Error(error as string);
     }
-    data = values;
-  } catch (error:any) {
-    throw new Error(error);
-  }
 
-  return data;
+    return data;
 }
 
-
-
-
 /**
  * @description Returns True if obj is non-string iterable, False otherwise
 
@@ -68,27 +69,101 @@ function extractElementValues(element: any, values: any) {
 //     return  instanceof(obj, (str, bytes)) && instanceof(obj, Iterable))
 // }
 
+export function nowUTC(): Date {
+    return new Date();
+}
 
+export function range(start: number, stop: number, step: number) {
+    if (typeof stop == 'undefined') {
+        // one param defined
+        stop = start;
+        start = 0;
+    }
 
-export function range(start: any, stop: any, step: any) {
-  if (typeof stop == 'undefined') {
-    // one param defined
-    stop = start;
-    start = 0;
-  }
+    if (typeof step == 'undefined') {
+        step = 1;
+    }
 
-  if (typeof step == 'undefined') {
-    step = 1;
-  }
+    if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
+        return [];
+    }
 
-  if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
-    return [];
-  }
+    const result = new Array<number>();
+    for (let i: number = start; step > 0 ? i < stop : i > stop; i += step) {
+        result.push(i);
+    }
 
-  let result = [];
-  for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
-    result.push(i);
-  }
+    return result;
+}
 
-  return result;
-}
+export function intToBytes(value: number, length: number): Uint8Array {
+    const byteArray = new Uint8Array(length); // Assuming a 4-byte integer (32 bits)
+
+    for (let index = byteArray.length - 1; index >= 0; index--) {
+        const byte = value & 0xff;
+        byteArray[index] = byte;
+        value = (value - byte) / 256;
+    }
+    return byteArray;
+}
+
+export function bytesToInt(ar: Uint8Array): number {
+    let value = 0;
+    for (let i = 0; i < ar.length; i++) {
+        value = value * 256 + ar[i];
+    }
+    return value;
+}
+
+export function serializeACDCAttachment(anc: Serder): Uint8Array {
+    const prefixer = new Prefixer({ qb64: anc.pre });
+    const seqner = new Seqner({ sn: anc.sn });
+    const saider = new Saider({ qb64: anc.ked['d'] });
+    const craw = new Uint8Array();
+    const ctr = new Counter({ code: CtrDex.SealSourceTriples, count: 1 }).qb64b;
+    const prefix = prefixer.qb64b;
+    const seq = seqner.qb64b;
+    const said = saider.qb64b;
+    const newCraw = new Uint8Array(
+        craw.length + ctr.length + prefix.length + seq.length + said.length
+    );
+    newCraw.set(craw);
+    newCraw.set(ctr, craw.length);
+    newCraw.set(prefix, craw.length + ctr.length);
+    newCraw.set(seq, craw.length + ctr.length + prefix.length);
+    newCraw.set(said, craw.length + ctr.length + prefix.length + seq.length);
+    return newCraw;
+}
+
+export function serializeIssExnAttachment(anc: Serder): Uint8Array {
+    const seqner = new Seqner({ sn: anc.sn });
+    const ancSaider = new Saider({ qb64: anc.ked['d'] });
+    const coupleArray = new Uint8Array(
+        seqner.qb64b.length + ancSaider.qb64b.length
+    );
+    coupleArray.set(seqner.qb64b);
+    coupleArray.set(ancSaider.qb64b, seqner.qb64b.length);
+    const counter = new Counter({
+        code: CtrDex.SealSourceCouples,
+        count: 1,
+    });
+    const counterQb64b = counter.qb64b;
+    const atc = new Uint8Array(counter.qb64b.length + coupleArray.length);
+    atc.set(counterQb64b);
+    atc.set(coupleArray, counterQb64b.length);
+
+    if (atc.length % 4 !== 0) {
+        throw new Error(
+            `Invalid attachments size: ${atc.length}, non-integral quadlets detected.`
+        );
+    }
+    const pcnt = new Counter({
+        code: CtrDex.AttachedMaterialQuadlets,
+        count: Math.floor(atc.length / 4),
+    });
+    const msg = new Uint8Array(pcnt.qb64b.length + atc.length);
+    msg.set(pcnt.qb64b);
+    msg.set(atc, pcnt.qb64b.length);
+
+    return msg;
+}

package/src/keri/core/vdring.ts

@@ -0,0 +1,94 @@
+import { randomNonce } from '../app/coring';
+import { TraitDex } from '../app/habery';
+import {
+    Serials,
+    Versionage,
+    Version,
+    Ident,
+    versify,
+    Ilks,
+} from '../core/core';
+import { ample } from './eventing';
+import { MtrDex } from './matter';
+import { Prefixer } from './prefixer';
+import { Serder } from './serder';
+
+namespace vdr {
+    export interface VDRInceptArgs {
+        pre: string;
+        toad?: number | string;
+        nonce?: string;
+        baks?: string[];
+        cnfg?: string[];
+        version?: Version;
+        kind?: Serials;
+        code?: string;
+    }
+
+    export function incept({
+        pre,
+        toad,
+        nonce = randomNonce(),
+        baks = [],
+        cnfg = [],
+        version = Versionage,
+        kind = Serials.JSON,
+        code = MtrDex.Blake3_256,
+    }: VDRInceptArgs): Serder {
+        const vs = versify(Ident.KERI, version, kind, 0);
+        const isn = 0;
+        const ilk = Ilks.vcp;
+
+        if (cnfg.includes(TraitDex.NoBackers) && baks.length > 0) {
+            throw new Error(
+                `${baks.length} backers specified for NB vcp, 0 allowed`
+            );
+        }
+
+        if (new Set(baks).size < baks.length) {
+            throw new Error(`Invalid baks ${baks} has duplicates`);
+        }
+
+        let _toad: number;
+        if (toad === undefined) {
+            if (baks.length === 0) {
+                _toad = 0;
+            } else {
+                _toad = ample(baks.length);
+            }
+        } else {
+            _toad = +toad;
+        }
+
+        if (baks.length > 0) {
+            if (_toad < 1 || _toad > baks.length) {
+                throw new Error(`Invalid toad ${_toad} for baks in ${baks}`);
+            }
+        } else {
+            if (_toad != 0) {
+                throw new Error(`Invalid toad ${_toad} for no baks`);
+            }
+        }
+
+        const ked = {
+            v: vs,
+            t: ilk,
+            d: '',
+            i: '',
+            ii: pre,
+            s: '' + isn,
+            c: cnfg,
+            bt: _toad.toString(16),
+            b: baks,
+            n: nonce,
+        };
+
+        const prefixer = new Prefixer({ code }, ked);
+        ked.i = prefixer.qb64;
+        ked.d = prefixer.qb64;
+
+        return new Serder(ked);
+    }
+}
+
+export { vdr };

package/src/keri/core/verfer.ts

@@ -1,33 +1,47 @@
 export {};
-const libsodium = require('libsodium-wrappers-sumo');
-const {Matter} = require('./matter');
-import {MatterArgs, MtrDex} from './matter';
+import libsodium from 'libsodium-wrappers-sumo';
+import { Matter, MatterArgs, MtrDex } from './matter';
+import secp256r1 from 'ecdsa-secp256r1';
 
 /**
  * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
  *  using .raw as verifier key and .code as signature cypher suite
  */
 export class Verfer extends Matter {
-    constructor({raw, code, qb64, qb64b, qb2}: MatterArgs) {
-        super({raw, code, qb64, qb64b, qb2});
+    private readonly _verify: (sig: any, ser: any, key: any) => boolean;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs) {
+        super({ raw, code, qb64, qb64b, qb2 });
 
         if (Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(this.code)) {
-            this._verify = this._ed25519
+            this._verify = this._ed25519;
+        } else if (
+            Array.from([MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256r1]).includes(
+                this.code
+            )
+        ) {
+            this._verify = this._secp256r1;
         } else {
-            throw new Error(`Unsupported code = ${this.code} for verifier.`)
+            throw new Error(`Unsupported code = ${this.code} for verifier.`);
         }
     }
 
     verify(sig: any, ser: any) {
-        return this._verify(sig, ser, this.raw)
+        return this._verify(sig, ser, this.raw);
     }
 
     _ed25519(sig: any, ser: any, key: any) {
         try {
             return libsodium.crypto_sign_verify_detached(sig, ser, key);
-
-        } catch (error: any) {
-            throw new Error(error);
+        } catch (error) {
+            throw new Error(error as string);
+        }
+    }
+    _secp256r1(sig: any, ser: any, key: any) {
+        try {
+            const publicKey = secp256r1.fromCompressedPublicKey(key);
+            return publicKey.verify(ser, sig);
+        } catch (error) {
+            throw new Error(error as string);
         }
     }
 }