signify-ts 0.1.1 → 0.2.1

package/src/keri/core/counter.ts

@@ -1,97 +1,151 @@
-import {Codex, Sizage} from "./matter";
-import {b, b64ToInt, d, intToB64} from "./core";
+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
+    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
+    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 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 = "";
+    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) {
+    constructor({ code, count, countB64, qb64b, qb64, qb2 }: CounterArgs) {
         if (code != undefined) {
             if (!Counter.Sizes.has(code)) {
-                throw new Error(`"Unsupported code=${code}.`)
+                throw new Error(`"Unsupported code=${code}.`);
             }
 
-            let sizage = Counter.Sizes.get(code)!
-            let cs = sizage.hs + sizage.ss
+            const sizage = Counter.Sizes.get(code)!;
+            const 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}.`)
+                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)
+                count = countB64 == undefined ? 1 : b64ToInt(countB64);
             }
 
-            if (count < 0 || count > (64 ** sizage.ss - 1)) {
-                throw new Error(`Invalid count=${count} for code=${code}.`)
+            if (count < 0 || count > 64 ** sizage.ss - 1) {
+                throw new Error(`Invalid count=${count} for code=${code}.`);
             }
 
-            this._code = code
-            this._count = count
-
+            this._code = code;
+            this._count = count;
         } else if (qb64b != undefined) {
-            let qb64 = d(qb64b)
-            this._exfil(qb64)
+            const qb64 = d(qb64b);
+            this._exfil(qb64);
         } else if (qb64 != undefined) {
-            this._exfil(qb64)
+            this._exfil(qb64);
         } else if (qb2 != undefined) {
-
         } else {
-            throw new Error(`Improper initialization need either (code and count) or qb64b or qb64 or qb2.`)
+            throw new Error(
+                `Improper initialization need either (code and count) or qb64b or qb64 or qb2.`
+            );
         }
     }
 
@@ -108,100 +162,112 @@ export class Counter {
     }
 
     get qb64b() {
-        return b(this.qb64)
+        return b(this.qb64);
     }
 
     countToB64(l?: number): string {
         if (l == undefined) {
-            let sizage = Counter.Sizes.get(this.code)!
-            l = sizage.ss
+            const sizage = Counter.Sizes.get(this.code)!;
+            l = sizage.ss;
         }
-        return intToB64(this.count, l)
+        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
+    static semVerToB64(
+        version: string = '',
+        major: number = 0,
+        minor: number = 0,
+        patch: number = 0
+    ): string {
+        let parts = [major, minor, patch];
+        if (version != '') {
+            const ssplits = version.split('.');
+            const splits = ssplits.map((x) => {
+                if (x == '') return 0;
+                return parseInt(x);
+            });
+
+            const off = splits.length;
+            const x = 3 - off;
             for (let i = 0; i < x; i++) {
-                splits.push(parts[i + off])
+                splits.push(parts[i + off]);
             }
-            parts = splits
+            parts = splits;
         }
 
         parts.forEach((p) => {
-            if(p < 0 || p > 63) {
-                throw new Error(`Out of bounds semantic version. Part=${p} is < 0 or > 63.`)
+            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("")
+        return parts
+            .map((p) => {
+                return intToB64(p, 1);
+            })
+            .join('');
     }
 
     private _infil(): string {
-        let code = this.code;
-        let count = this.count;
+        const code = this.code;
+        const count = this.count;
 
-        let sizage = Counter.Sizes.get(code)!;
-        let cs = sizage.hs + sizage.ss
+        const sizage = Counter.Sizes.get(code)!;
+        const 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}.`)
+            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}.`)
+        if (count < 0 || count > 64 ** sizage.ss - 1) {
+            throw new Error(`Invalid count=${count} for code=${code}.`);
         }
 
-        let both = `${code}${intToB64(count, sizage.ss)}`
+        const both = `${code}${intToB64(count, sizage.ss)}`;
 
         if (both.length % 4) {
-            throw new Error(`Invalid size = ${both.length} of ${both} not a multiple of 4.`)
+            throw new Error(
+                `Invalid size = ${both.length} of ${both} not a multiple of 4.`
+            );
         }
 
-        return both
+        return both;
     }
 
     private _exfil(qb64: string) {
         if (qb64.length == 0) {
-            throw new Error("Empty Material")
+            throw new Error('Empty Material');
         }
 
-        let first = qb64.slice(0, 2);
+        const first = qb64.slice(0, 2);
         if (!Counter.Hards.has(first)) {
-            throw new Error(`Unexpected code ${first}`)
+            throw new Error(`Unexpected code ${first}`);
         }
 
-        let hs = Counter.Hards.get(first)!;
+        const hs = Counter.Hards.get(first)!;
         if (qb64.length < hs) {
-            throw new Error(`Need ${hs - qb64.length} more characters.`)
+            throw new Error(`Need ${hs - qb64.length} more characters.`);
         }
 
-        let hard = qb64.slice(0, hs);
+        const hard = qb64.slice(0, hs);
         if (!Counter.Sizes.has(hard)) {
-            throw new Error(`Unsupported code ${hard}`)
+            throw new Error(`Unsupported code ${hard}`);
         }
 
-        let sizage = Counter.Sizes.get(hard)!;
-        let cs = sizage!.hs + sizage!.ss;
+        const sizage = Counter.Sizes.get(hard)!;
+        const cs = sizage!.hs + sizage!.ss;
 
         if (qb64.length < cs) {
-            throw new Error(`Need ${cs - qb64.length} more chars.`)
+            throw new Error(`Need ${cs - qb64.length} more chars.`);
         }
 
-        let scount = qb64.slice(sizage.hs, sizage.hs + sizage.ss)
-        let count = b64ToInt(scount)
+        const scount = qb64.slice(sizage.hs, sizage.hs + sizage.ss);
+        const count = b64ToInt(scount);
 
-        this._code = hard
-        this._count = count
+        this._code = hard;
+        this._count = count;
     }
-
-}
+}

package/src/keri/core/decrypter.ts

@@ -1,66 +1,80 @@
-import libsodium from "libsodium-wrappers-sumo";
-
-import {Matter, MatterArgs, MtrDex} from './matter';
-import {Signer} from "./signer";
-import {Cipher} from "./cipher";
-import {EmptyMaterialError} from "./kering";
-import {Salter} from "./salter";
+import libsodium from 'libsodium-wrappers-sumo';
 
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { Signer } from './signer';
+import { Cipher } from './cipher';
+import { EmptyMaterialError } from './kering';
+import { Salter } from './salter';
 
 export class Decrypter extends Matter {
     private readonly _decrypt: any;
-    constructor({raw, code = MtrDex.X25519_Private, qb64, qb64b, qb2}:MatterArgs, seed: Uint8Array | undefined = undefined) {
+    constructor(
+        { raw, code = MtrDex.X25519_Private, qb64, qb64b, qb2 }: MatterArgs,
+        seed: Uint8Array | undefined = undefined
+    ) {
         try {
-            super({raw, code, qb64, qb64b, qb2})
-        } catch(e) {
-            if(e instanceof EmptyMaterialError) {
+            super({ raw, code, qb64, qb64b, qb2 });
+        } catch (e) {
+            if (e instanceof EmptyMaterialError) {
                 if (seed != undefined) {
-                    let signer = new Signer({qb64b: seed})
+                    const signer = new Signer({ qb64b: seed });
                     if (signer.code != MtrDex.Ed25519_Seed) {
-                        throw new Error(`Unsupported signing seed derivation code ${signer.code}`)
+                        throw new Error(
+                            `Unsupported signing seed derivation code ${signer.code}`
+                        );
                     }
-                    let sigkey = new Uint8Array(signer.raw.length + signer.verfer.raw.length)
-                    sigkey.set(signer.raw)
-                    sigkey.set(signer.verfer.raw, signer.raw.length)
-                    raw = libsodium.crypto_sign_ed25519_sk_to_curve25519(sigkey)
-                    super({raw, code, qb64, qb64b, qb2})
-                }
-                else {
-                    throw e
+                    const sigkey = new Uint8Array(
+                        signer.raw.length + signer.verfer.raw.length
+                    );
+                    sigkey.set(signer.raw);
+                    sigkey.set(signer.verfer.raw, signer.raw.length);
+                    raw =
+                        libsodium.crypto_sign_ed25519_sk_to_curve25519(sigkey);
+                    super({ raw, code, qb64, qb64b, qb2 });
+                } else {
+                    throw e;
                 }
             } else {
-                throw e
+                throw e;
             }
         }
 
         if (this.code == MtrDex.X25519_Private) {
-            this._decrypt = this._x25519
+            this._decrypt = this._x25519;
         } else {
-            throw new Error(`Unsupported decrypter code = ${this.code}.`)
+            throw new Error(`Unsupported decrypter code = ${this.code}.`);
         }
     }
 
-    decrypt(ser: Uint8Array | null = null, cipher: Cipher | null = null, transferable: boolean = false) {
+    decrypt(
+        ser: Uint8Array | null = null,
+        cipher: Cipher | null = null,
+        transferable: boolean = false
+    ) {
         if (ser == null && cipher == null) {
-            throw new EmptyMaterialError("Neither ser or cipher were provided")
+            throw new EmptyMaterialError('Neither ser or cipher were provided');
         }
 
         if (ser != null) {
-            cipher = new Cipher({qb64b: ser})
+            cipher = new Cipher({ qb64b: ser });
         }
 
-        return this._decrypt(cipher, this.raw, transferable)
+        return this._decrypt(cipher, this.raw, transferable);
     }
 
     _x25519(cipher: Cipher, prikey: Uint8Array, transferable: boolean = false) {
-        let pubkey = libsodium.crypto_scalarmult_base(prikey)
-        let plain = libsodium.crypto_box_seal_open(cipher.raw, pubkey, prikey)
+        const pubkey = libsodium.crypto_scalarmult_base(prikey);
+        const plain = libsodium.crypto_box_seal_open(
+            cipher.raw,
+            pubkey,
+            prikey
+        );
         if (cipher.code == MtrDex.X25519_Cipher_Salt) {
-            return new Salter({qb64b: plain})
+            return new Salter({ qb64b: plain });
         } else if (cipher.code == MtrDex.X25519_Cipher_Seed) {
-            return new Signer({qb64b: plain, transferable: transferable})
+            return new Signer({ qb64b: plain, transferable: transferable });
         } else {
-            throw new Error(`Unsupported cipher text code == ${cipher.code}`)
+            throw new Error(`Unsupported cipher text code == ${cipher.code}`);
         }
     }
-}
+}

package/src/keri/core/diger.ts

@@ -1,6 +1,6 @@
-import {createHash} from "blake3"
+import { blake3 } from '@noble/hashes/blake3';
 
-import {Matter, MatterArgs, MtrDex} from './matter';
+import { Matter, MatterArgs, MtrDex } from './matter';
 
 /**
  * @description : Diger is subset of Matter and is used to verify the digest of serialization
@@ -10,21 +10,25 @@ import {Matter, MatterArgs, MtrDex} from './matter';
  */
 
 export class Diger extends Matter {
-    private readonly _verify: any
+    private readonly _verify: any;
 
     // This constructor will assign digest verification function to ._verify
-    constructor({raw, code = MtrDex.Blake3_256, qb64, qb64b, qb2}: MatterArgs, ser: Uint8Array | null = null) {
+    constructor(
+        { raw, code = MtrDex.Blake3_256, qb64, qb64b, qb2 }: MatterArgs,
+        ser: Uint8Array | null = null
+    ) {
         try {
-            super({raw, code, qb64, qb64b, qb2});
+            super({ raw, code, qb64, qb64b, qb2 });
         } catch (error) {
             if (ser == null) {
                 throw error;
             }
 
             if (code === MtrDex.Blake3_256) {
-                const hasher = createHash();
-                const dig = hasher.update(ser).digest('');
-                super({raw: dig, code: code});
+                const dig = Buffer.from(
+                    blake3.create({ dkLen: 32 }).update(ser).digest()
+                );
+                super({ raw: dig, code: code });
             } else {
                 throw new Error(`Unsupported code = ${code} for digester.`);
             }
@@ -37,7 +41,6 @@ export class Diger extends Matter {
         }
     }
 
-
     /**
      *
      * @param {Uint8Array} ser  serialization bytes
@@ -49,34 +52,32 @@ export class Diger extends Matter {
         return this._verify(ser, this.raw);
     }
 
-    compare(ser: Uint8Array, dig: any = null, diger: Diger | null = null ) {
+    compare(ser: Uint8Array, dig: any = null, diger: Diger | null = null) {
         if (dig != null) {
             if (dig.toString() == this.qb64) {
-                return true
+                return true;
             }
 
-            diger = new Diger({qb64b: dig})
+            diger = new Diger({ qb64b: dig });
         } else if (diger != null) {
             if (diger.qb64b == this.qb64b) {
                 return true;
             }
-        }
-
-        else {
-            throw new Error("Both dig and diger may not be None.")
+        } else {
+            throw new Error('Both dig and diger may not be None.');
         }
 
         if (diger.code == this.code) {
-            return false
+            return false;
         }
 
-        return diger.verify(ser) && this.verify(ser)
+        return diger.verify(ser) && this.verify(ser);
     }
 
-
     blake3_256(ser: Uint8Array, dig: any) {
-        const hasher = createHash();
-        let digest = hasher.update(ser).digest('');
-        return (digest.toString() === dig.toString());
+        const digest = Buffer.from(
+            blake3.create({ dkLen: 32 }).update(ser).digest()
+        );
+        return digest.toString() === dig.toString();
     }
 }