signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/dist/keri/core/serder.js

@@ -0,0 +1,133 @@
+import { MtrDex } from "./matter.js";
+import { deversify, Protocols, Serials, versify, Vrsn_1_0, } from "./core.js";
+import { Verfer } from "./verfer.js";
+import { Diger } from "./diger.js";
+import { CesrNumber } from "./number.js";
+export class Serder {
+    /**
+     * Creates a new Serder object from a self-addressing data dictionary.
+     * @param sad self-addressing data dictionary.
+     * @param kind serialization type to produce
+     * @param code derivation code for the prefix
+     */
+    constructor(sad, kind = Serials.JSON, code = MtrDex.Blake3_256) {
+        this._raw = '';
+        this._sad = {};
+        this._proto = Protocols.KERI;
+        this._size = 0;
+        this._version = Vrsn_1_0;
+        const [raw, proto, eKind, eSad, version] = this._exhale(sad, kind);
+        this._raw = raw;
+        this._sad = eSad;
+        this._proto = proto;
+        this._version = version;
+        this._code = code;
+        this._kind = eKind;
+        this._size = raw.length;
+    }
+    get sad() {
+        return this._sad;
+    }
+    get pre() {
+        return this._sad['i'];
+    }
+    get code() {
+        return this._code;
+    }
+    get raw() {
+        return this._raw;
+    }
+    get said() {
+        return this._sad['d'];
+    }
+    get sner() {
+        return new CesrNumber({}, this.sad['s']);
+    }
+    get sn() {
+        return this.sner.num;
+    }
+    get kind() {
+        return this._kind;
+    }
+    /**
+     * Serializes a self-addressing data dictionary from the dictionary passed in
+     * using the specified serialization type.
+     * @param sad self-addressing data dictionary.
+     * @param kind serialization type to produce
+     * @private
+     */
+    _exhale(sad, kind) {
+        return sizeify(sad, kind);
+    }
+    get proto() {
+        return this._proto;
+    }
+    get size() {
+        return this._size;
+    }
+    get version() {
+        return this._version;
+    }
+    get verfers() {
+        let keys = [];
+        if ('k' in this._sad) {
+            // establishment event
+            keys = this._sad['k'];
+        }
+        else {
+            // non-establishment event
+            keys = [];
+        }
+        // create a new Verfer for each key
+        const verfers = [];
+        for (const key of keys) {
+            verfers.push(new Verfer({ qb64: key }));
+        }
+        return verfers;
+    }
+    get digers() {
+        let keys = [];
+        if ('n' in this._sad) {
+            // establishment event
+            keys = this._sad['n'];
+        }
+        else {
+            // non-establishment event
+            keys = [];
+        }
+        // create a new Verfer for each key
+        const digers = [];
+        for (const key of keys) {
+            digers.push(new Diger({ qb64: key }));
+        }
+        return digers;
+    }
+    pretty() {
+        return JSON.stringify(this._sad, undefined, 2);
+    }
+}
+export function dumps(sad, kind) {
+    if (kind == Serials.JSON) {
+        return JSON.stringify(sad);
+    }
+    else {
+        throw new Error('unsupported event encoding');
+    }
+}
+export function sizeify(ked, kind) {
+    if (!('v' in ked)) {
+        throw new Error('Missing or empty version string');
+    }
+    const [proto, knd, version] = deversify(ked['v']);
+    if (version != Vrsn_1_0) {
+        throw new Error(`unsupported version ${version.toString()}`);
+    }
+    if (kind == undefined) {
+        kind = knd;
+    }
+    let raw = dumps(ked, kind);
+    const size = new TextEncoder().encode(raw).length;
+    ked['v'] = versify(proto, version, kind, size);
+    raw = dumps(ked, kind);
+    return [raw, proto, kind, ked, version];
+}

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

@@ -1,5 +1,5 @@
-import { Indexer, IndexerArgs } from './indexer';
-import { Verfer } from './verfer';
+import { Indexer, IndexerArgs } from './indexer.ts';
+import { Verfer } from './verfer.ts';
 /**
    Siger is subclass of Indexer, indexed signature material,
     Adds .verfer property which is instance of Verfer that provides

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

@@ -1,6 +1,4 @@
-import { IdxSigDex, Indexer, IndexerArgs } from './indexer';
-import { Verfer } from './verfer';
-
+import { IdxSigDex, Indexer } from "./indexer.js";
 /**
    Siger is subclass of Indexer, indexed signature material,
     Adds .verfer property which is instance of Verfer that provides
@@ -15,26 +13,18 @@ import { Verfer } from './verfer';
 
     Methods:
  **/
-
 export class Siger extends Indexer {
-    private _verfer?: Verfer;
-    constructor(
-        { raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs,
-        verfer?: Verfer
-    ) {
+    constructor({ raw, code, index, ondex, qb64, qb64b, qb2 }, 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;
     }
-
-    get verfer(): Verfer | undefined {
+    get verfer() {
         return this._verfer;
     }
-
-    set verfer(verfer: Verfer | undefined) {
+    set verfer(verfer) {
         this._verfer = verfer;
     }
 }

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

@@ -1,8 +1,8 @@
 export {};
-import { Matter } from './matter';
-import { Verfer } from './verfer';
-import { Cigar } from './cigar';
-import { Siger } from './siger';
+import { Matter } from './matter.ts';
+import { Verfer } from './verfer.ts';
+import { Cigar } from './cigar.ts';
+import { Siger } from './siger.ts';
 /**
  * @description Signer is Matter subclass with method to create signature of serialization
  * It will use .raw as signing (private) key seed

package/dist/keri/core/signer.js

@@ -0,0 +1,84 @@
+import { EmptyMaterialError } from "./kering.js";
+import libsodium from 'libsodium-wrappers-sumo';
+import { Matter } from "./matter.js";
+import { MtrDex } from "./matter.js";
+import { Verfer } from "./verfer.js";
+import { Cigar } from "./cigar.js";
+import { Siger } from "./siger.js";
+import { IdrDex } from "./indexer.js";
+import { concat } from "./core.js";
+export class Signer extends Matter {
+    constructor({ raw, code = MtrDex.Ed25519_Seed, qb64, qb64b, qb2, transferable = true, }) {
+        try {
+            super({ raw, code, qb64, qb64b, qb2 });
+        }
+        catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (code == MtrDex.Ed25519_Seed) {
+                    const raw = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
+                    super({ raw, code, qb64, qb64b, qb2 });
+                }
+                else {
+                    throw new Error(`Unsupported signer code = ${code}.`);
+                }
+            }
+            else {
+                throw e;
+            }
+        }
+        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,
+            });
+        }
+        else {
+            throw new Error(`Unsupported signer code = ${this.code}.`);
+        }
+        this._verfer = verfer;
+    }
+    /**
+     * @description Property verfer:
+     Returns Verfer instance
+     Assumes ._verfer is correctly assigned
+     */
+    get verfer() {
+        return this._verfer;
+    }
+    sign(ser, index = null, only = false, ondex = undefined) {
+        return this._sign(ser, this.raw, this.verfer, index, only, ondex);
+    }
+    _ed25519(ser, seed, verfer, index, only = false, ondex) {
+        const sig = libsodium.crypto_sign_detached(ser, concat(seed, verfer.raw));
+        if (index == null) {
+            return new Cigar({ raw: sig, code: MtrDex.Ed25519_Sig }, verfer);
+        }
+        else {
+            let code;
+            if (only) {
+                ondex = undefined;
+                if (index <= 63) {
+                    code = IdrDex.Ed25519_Crt_Sig;
+                }
+                else {
+                    code = IdrDex.Ed25519_Big_Crt_Sig;
+                }
+            }
+            else {
+                if (ondex == undefined) {
+                    ondex = index;
+                }
+                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);
+        }
+    }
+}

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

@@ -1,83 +1,76 @@
-import { BexDex, Matter, NumDex } from './matter';
-import { CesrNumber } from './number';
-import { Fraction } from 'mathjs';
-import { math } from '../../index';
-
+import { BexDex, Matter, NumDex } from "./matter.js";
+import { CesrNumber } from "./number.js";
+import { format, sum, fraction } from 'mathjs';
 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 }) {
+    constructor(kargs) {
+        this._weighted = false;
+        this._thold = undefined;
+        this._size = 0;
+        this._number = undefined;
+        this._satisfy = undefined;
         if (kargs.thold !== undefined) {
             this._processThold(kargs.thold);
-        } else if (kargs.limen != undefined) {
+        }
+        else if (kargs.limen != undefined) {
             this._processLimen(kargs.limen);
-        } else if (kargs.sith !== undefined) {
+        }
+        else if (kargs.sith !== undefined) {
             this._processSith(kargs.sith);
-        } else {
+        }
+        else {
             throw new Error('Missing threshold expression');
         }
     }
-
-    get weighted(): boolean {
+    get weighted() {
         return this._weighted;
     }
-
-    get thold(): any {
+    get thold() {
         return this._thold;
     }
-
-    get size(): number {
+    get size() {
         return this._size;
     }
-
-    get limen(): any {
-        return this._number?.qb64b;
+    get limen() {
+        var _a;
+        return (_a = this._number) === null || _a === void 0 ? void 0 : _a.qb64b;
     }
-
-    get sith(): string {
+    get sith() {
         if (this.weighted) {
-            let sith = this.thold.map((clause: Fraction[]) => {
+            let sith = this.thold.map((clause) => {
                 return clause.map((c) => {
                     if (0 < Number(c) && Number(c) < 1) {
-                        return math.format(c, { fraction: 'ratio' });
-                    } else {
-                        return math.format(c, { fraction: 'decimal' });
+                        return format(c, { fraction: 'ratio' });
+                    }
+                    else {
+                        return format(c, { fraction: 'decimal' });
                     }
                 });
             });
             if (sith.length == 1) {
                 sith = sith[0];
             }
-
             return sith;
-        } else {
+        }
+        else {
             return this.thold.toString(16);
         }
     }
-
-    get json(): string {
+    get json() {
         return JSON.stringify(this.sith);
     }
-
-    get num(): number | undefined {
+    get num() {
         return this._weighted ? undefined : this._thold;
     }
-
-    private _processThold(thold: number | Array<Array<Fraction>>) {
+    _processThold(thold) {
         if (typeof thold === 'number') {
             this._processUnweighted(thold);
-        } else {
+        }
+        else {
             this._processWeighted(thold);
         }
     }
-
-    private _processLimen(limen: string) {
+    _processLimen(limen) {
         const matter = new Matter({ qb64: limen });
         if (NumDex.has(matter.code)) {
             const number = new CesrNumber({
@@ -85,67 +78,59 @@ export class Tholder {
                 code: matter.code,
             });
             this._processUnweighted(number.num);
-        } else if (BexDex.has(matter.code)) {
+        }
+        else if (BexDex.has(matter.code)) {
             // TODO: Implement Bexter
-        } else {
+        }
+        else {
             throw new Error('Invalid code for limen=' + matter.code);
         }
     }
-
-    private _processSith(sith: string | number | Array<string>) {
+    _processSith(sith) {
         if (typeof sith == 'number') {
             this._processUnweighted(sith);
-        } else if (typeof sith == 'string' && sith.indexOf('[') == -1) {
+        }
+        else if (typeof sith == 'string' && sith.indexOf('[') == -1) {
             this._processUnweighted(parseInt(sith, 16));
-        } else {
-            let _sith: any = sith;
+        }
+        else {
+            let _sith = 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) => {
+            const mask = _sith.map((x) => {
                 return typeof x !== 'string';
             });
-
-            if (mask.length > 0 && !mask.every((x: boolean) => x)) {
+            if (mask.length > 0 && !mask.every((x) => x)) {
                 _sith = [_sith];
             }
-
             for (const c of _sith) {
-                const mask = c.map((x: any) => {
+                const mask = c.map((x) => {
                     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'
-                    );
+                if (mask.length > 0 && !mask.every((x) => 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>>();
+    _processClauses(sith) {
+        const thold = new Array();
         sith.forEach((clause) => {
-            thold.push(
-                clause.map((w) => {
-                    return this.weight(w);
-                })
-            );
+            thold.push(clause.map((w) => {
+                return this.weight(w);
+            }));
         });
         return thold;
     }
-
-    private _processUnweighted(thold: number) {
+    _processUnweighted(thold) {
         if (thold < 0) {
             throw new Error('Non-positive int threshold = {thold}.');
         }
@@ -156,18 +141,14 @@ export class Tholder {
         this._number = new CesrNumber({}, thold);
         // this._bexter = undefined
     }
-
-    private _processWeighted(thold: Array<Array<Fraction>>) {
+    _processWeighted(thold) {
         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'
-                );
+            if (Number(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) => {
@@ -176,21 +157,17 @@ export class Tholder {
         this._satisfy = this._satisfy_weighted;
         //TODO: created Bexter if needed
     }
-
-    private weight(w: string): Fraction {
-        return math.fraction(w);
+    weight(w) {
+        return fraction(w);
     }
-
-    private _satisfy_numeric(indices: any[]) {
+    _satisfy_numeric(indices) {
         return this.thold > 0 && indices.length >= this.thold; // at least one
     }
-
-    private _satisfy_weighted(indices: any) {
+    _satisfy_weighted(indices) {
         if (indices.length === 0) {
             return false;
         }
-
-        const indexes: Set<number> = new Set(indices.sort());
+        const indexes = new Set(indices.sort());
         const sats = new Array(indices.length).fill(false);
         for (const idx of indexes) {
             sats[idx] = true;
@@ -208,11 +185,9 @@ export class Tholder {
                 return false;
             }
         }
-
         return true;
     }
-
-    public satisfy(indices: any): boolean {
+    satisfy(indices) {
         return this._satisfy(indices);
     }
 }

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

@@ -1,4 +1,4 @@
-import { Serder } from './serder';
+import { Serder } from './serder.ts';
 export declare function pad(n: any, width?: number, z?: number): string;
 /**
  * @description  Returns list of depth first recursively extracted values from elements of