signify-ts 0.1.1 → 0.2.1

package/src/keri/core/siger.ts

@@ -1,5 +1,5 @@
-import {IdxSigDex, Indexer, IndexerArgs} from "./indexer";
-import {Verfer} from "./verfer";
+import { IdxSigDex, Indexer, IndexerArgs } from './indexer';
+import { Verfer } from './verfer';
 
 /**
    Siger is subclass of Indexer, indexed signature material,
@@ -17,23 +17,24 @@ import {Verfer} from "./verfer";
  **/
 
 export class Siger extends Indexer {
-
-  private _verfer?: Verfer
-  constructor({raw, code, index, ondex, qb64, qb64b, qb2}: IndexerArgs, verfer?: Verfer) {
-    super({raw, code, index, ondex, qb64, qb64b, qb2});
-
-    if (!IdxSigDex.has(this.code)) {
-      throw new Error(`Invalid code = ${this.code} for Siger.`)
+    private _verfer?: Verfer;
+    constructor(
+        { raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs,
+        verfer?: Verfer
+    ) {
+        super({ raw, code, index, ondex, qb64, qb64b, qb2 });
+
+        if (!IdxSigDex.has(this.code)) {
+            throw new Error(`Invalid code = ${this.code} for Siger.`);
+        }
+        this._verfer = verfer;
     }
-    this._verfer = verfer
-  }
-
-  get verfer(): Verfer | undefined {
-    return this._verfer;
-  }
 
-  set verfer(verfer: Verfer | undefined) {
-    this._verfer = verfer;
-  }
+    get verfer(): Verfer | undefined {
+        return this._verfer;
+    }
 
+    set verfer(verfer: Verfer | undefined) {
+        this._verfer = verfer;
+    }
 }

package/src/keri/core/signer.ts

@@ -1,13 +1,13 @@
-import {EmptyMaterialError} from "./kering";
+import { EmptyMaterialError } from './kering';
 
 export {};
 import libsodium from 'libsodium-wrappers-sumo';
-import {Matter} from './matter';
-import {MtrDex} from './matter';
-import {Verfer} from "./verfer";
-import {Cigar} from "./cigar";
-import {Siger} from "./siger";
-import {IdrDex} from "./indexer";
+import { Matter } from './matter';
+import { MtrDex } from './matter';
+import { Verfer } from './verfer';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+import { IdrDex } from './indexer';
 import { Buffer } from 'buffer';
 
 /**
@@ -19,48 +19,57 @@ import { Buffer } from 'buffer';
  as cipher suite for creating key-pair.
  */
 interface SignerArgs {
-    raw?: Uint8Array | undefined
-    code?: string
-    qb64b?: Uint8Array | undefined
-    qb64?: string
-    qb2?: Uint8Array | undefined
-    transferable?: boolean
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    transferable?: boolean;
 }
 
 export class Signer extends Matter {
-    private readonly _sign: Function
-    private readonly _verfer: Verfer
-
-    constructor({raw, code = MtrDex.Ed25519_Seed, qb64, qb64b, qb2, transferable = true}: SignerArgs) {
+    private readonly _sign: Function;
+    private readonly _verfer: Verfer;
+
+    constructor({
+        raw,
+        code = MtrDex.Ed25519_Seed,
+        qb64,
+        qb64b,
+        qb2,
+        transferable = true,
+    }: SignerArgs) {
         try {
-            super({raw, code, qb64, qb64b, qb2})
+            super({ raw, code, qb64, qb64b, qb2 });
         } catch (e) {
             if (e instanceof EmptyMaterialError) {
                 if (code == MtrDex.Ed25519_Seed) {
-                    let raw = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
-                    super({raw, code, qb64, qb64b, qb2})
+                    const raw = libsodium.randombytes_buf(
+                        libsodium.crypto_sign_SEEDBYTES
+                    );
+                    super({ raw, code, qb64, qb64b, qb2 });
                 } else {
-                    throw new Error(`Unsupported signer code = ${code}.`)
+                    throw new Error(`Unsupported signer code = ${code}.`);
                 }
             } else {
-                throw e
+                throw e;
             }
         }
-        let verfer
+        let verfer;
         if (this.code == MtrDex.Ed25519_Seed) {
-            this._sign = this._ed25519
-            const keypair = libsodium.crypto_sign_seed_keypair(this.raw)
-            verfer = new Verfer({raw: keypair.publicKey, code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N})
-
+            this._sign = this._ed25519;
+            const keypair = libsodium.crypto_sign_seed_keypair(this.raw);
+            verfer = new Verfer({
+                raw: keypair.publicKey,
+                code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N,
+            });
         } else {
-            throw new Error(`Unsupported signer code = ${this.code}.`)
+            throw new Error(`Unsupported signer code = ${this.code}.`);
         }
 
-        this._verfer = verfer
-
+        this._verfer = verfer;
     }
 
-
     /**
      * @description Property verfer:
      Returns Verfer instance
@@ -70,44 +79,55 @@ export class Signer extends Matter {
         return this._verfer;
     }
 
-    sign(ser: Uint8Array, index: number | null = null, only: boolean = false,
-         ondex: number | undefined = undefined): Siger | Cigar {
-        return this._sign(ser, this.raw, this.verfer, index, only, ondex)
+    sign(
+        ser: Uint8Array,
+        index: number | null = null,
+        only: boolean = false,
+        ondex: number | undefined = undefined
+    ): Siger | Cigar {
+        return this._sign(ser, this.raw, this.verfer, index, only, ondex);
     }
 
-    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null,
-             only: boolean = false, ondex: number | undefined) {
-
-        let sig = libsodium.crypto_sign_detached(
+    _ed25519(
+        ser: Uint8Array,
+        seed: Uint8Array,
+        verfer: Verfer,
+        index: number | null,
+        only: boolean = false,
+        ondex: number | undefined
+    ) {
+        const sig = libsodium.crypto_sign_detached(
             ser,
-            Buffer.concat([seed, verfer.raw]),
+            Buffer.concat([seed, verfer.raw])
         );
 
         if (index == null) {
-            return new Cigar({raw: sig, code: MtrDex.Ed25519_Sig}, verfer);
+            return new Cigar({ raw: sig, code: MtrDex.Ed25519_Sig }, verfer);
         } else {
             let code;
             if (only) {
-                ondex = undefined
+                ondex = undefined;
                 if (index <= 63) {
-                    code = IdrDex.Ed25519_Crt_Sig
+                    code = IdrDex.Ed25519_Crt_Sig;
                 } else {
-                    code = IdrDex.Ed25519_Big_Crt_Sig
+                    code = IdrDex.Ed25519_Big_Crt_Sig;
                 }
             } else {
-                if(ondex == undefined) {
-                    ondex = index
+                if (ondex == undefined) {
+                    ondex = index;
                 }
 
-                if (ondex == index && index <= 63) // both same and small
-                    code = IdrDex.Ed25519_Sig  //  use  small both same
-                else  //  otherwise big or both not same so use big both
-                    code = IdrDex.Ed25519_Big_Sig   // use use big both
-
+                if (ondex == index && index <= 63)
+                    // both same and small
+                    code = IdrDex.Ed25519_Sig; //  use  small both same
+                //  otherwise big or both not same so use big both
+                else code = IdrDex.Ed25519_Big_Sig; // use use big both
             }
 
-            return new Siger({raw: sig, code: code, index: index, ondex: ondex}, verfer)
+            return new Siger(
+                { raw: sig, code: code, index: index, ondex: ondex },
+                verfer
+            );
         }
-
     }
-}
+}

package/src/keri/core/tholder.ts

@@ -1,52 +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: number = 0
-    private _size: number = 0
-    private _sith: string = ""
-    private _limen: Array<string> = new Array<string>()
+    private _weighted: boolean = false;
+    private _thold: any = undefined;
+    private _size: number = 0;
+    private _number: CesrNumber | undefined = undefined;
+    private _satisfy: any = undefined;
 
-    constructor(sith: string | number | Array<string>) {
-        this.processSith(sith)
-    }
+    // private _bexter: any
 
-    get num(): number | undefined {
-        return this._weighted ? undefined : this._thold
+    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 size(): number {
-        return this._size
+    get weighted(): boolean {
+        return this._weighted;
     }
 
-    get thold(): number {
+    get thold(): any {
         return this._thold;
     }
-    get weighted(): boolean {
-        return this._weighted;
+
+    get size(): number {
+        return this._size;
+    }
+
+    get limen(): any {
+        return this._number?.qb64b;
     }
 
     get sith(): string {
         if (this.weighted) {
-            if (this._sith == "") {
-                return `${this._limen}`
+            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 this._sith
+
+            return sith;
         } else {
-            return this.thold.toString(16)
+            return this.thold.toString(16);
         }
     }
 
-    private processSith(sith: string | number | Array<string>) {
-        if (typeof(sith) == "string") {
-            this._sith = sith
-            this._thold = parseInt(sith)
-        } else if (typeof(sith) == "number") {
-            this._thold = sith
-            this._size = this._thold
+    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 {
-            this._limen = sith
-            this._size = this._limen.length
+            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) {
-    throw new Error(error as string);
-  }
 
-  return data;
+    return data;
 }
 
-
-
-
 /**
  * @description Returns True if obj is non-string iterable, False otherwise
 
@@ -68,31 +69,101 @@ function extractElementValues(element: any, values: any) {
 //     return  instanceof(obj, (str, bytes)) && instanceof(obj, Iterable))
 // }
 
-
 export function nowUTC(): Date {
-  return new Date()
+    return new Date();
 }
 
-
 export function range(start: number, stop: number, step: number) {
-  if (typeof stop == 'undefined') {
-    // one param defined
-    stop = start;
-    start = 0;
-  }
-
-  if (typeof step == 'undefined') {
-    step = 1;
-  }
-
-  if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
-    return [];
-  }
-
-  let result = new Array<number>();
-  for (let i: number = start; step > 0 ? i < stop : i > stop; i += step) {
-    result.push(i);
-  }
-
-  return result;
+    if (typeof stop == 'undefined') {
+        // one param defined
+        stop = start;
+        start = 0;
+    }
+
+    if (typeof step == 'undefined') {
+        step = 1;
+    }
+
+    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);
+    }
+
+    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;
 }