signify-ts 0.1.0 → 0.2.0

package/src/keri/core/counter.ts

@@ -0,0 +1,273 @@
+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}.`);
+            }
+
+            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}.`
+                );
+            }
+
+            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) {
+            const 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) {
+            const 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 != '') {
+            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]);
+            }
+            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 {
+        const code = this.code;
+        const count = this.count;
+
+        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}.`
+            );
+        }
+
+        if (count < 0 || count > 64 ** sizage.ss - 1) {
+            throw new Error(`Invalid count=${count} for code=${code}.`);
+        }
+
+        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.`
+            );
+        }
+
+        return both;
+    }
+
+    private _exfil(qb64: string) {
+        if (qb64.length == 0) {
+            throw new Error('Empty Material');
+        }
+
+        const first = qb64.slice(0, 2);
+        if (!Counter.Hards.has(first)) {
+            throw new Error(`Unexpected code ${first}`);
+        }
+
+        const hs = Counter.Hards.get(first)!;
+        if (qb64.length < hs) {
+            throw new Error(`Need ${hs - qb64.length} more characters.`);
+        }
+
+        const hard = qb64.slice(0, hs);
+        if (!Counter.Sizes.has(hard)) {
+            throw new Error(`Unsupported code ${hard}`);
+        }
+
+        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.`);
+        }
+
+        const scount = qb64.slice(sizage.hs, sizage.hs + sizage.ss);
+        const count = b64ToInt(scount);
+
+        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,5 +1,6 @@
-const blake3 = require('blake3');
-import {Matter, MatterArgs, MtrDex} from './matter';
+import { blake3 } from '@noble/hashes/blake3';
+
+import { Matter, MatterArgs, MtrDex } from './matter';
 
 /**
  * @description : Diger is subset of Matter and is used to verify the digest of serialization
@@ -8,23 +9,26 @@ 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});
-        } catch (error: any) {
+            super({ raw, code, qb64, qb64b, qb2 });
+        } catch (error) {
             if (ser == null) {
                 throw error;
             }
 
             if (code === MtrDex.Blake3_256) {
-                const hasher = blake3.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 = blake3.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();
     }
 }

package/src/keri/core/encrypter.ts

@@ -1,60 +1,70 @@
-import libsodium from "libsodium-wrappers-sumo";
-
-import {Matter, MatterArgs, MtrDex} from './matter';
-import {Verfer} from "./verfer";
-import {Signer} from "./signer";
-import {Cipher} from "./cipher";
-import {arrayEquals} from "./utils";
+import libsodium from 'libsodium-wrappers-sumo';
 
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { Verfer } from './verfer';
+import { Signer } from './signer';
+import { Cipher } from './cipher';
+import { arrayEquals } from './utils';
 
 export class Encrypter extends Matter {
     private _encrypt: any;
-    constructor({raw, code = MtrDex.X25519, qb64, qb64b, qb2}:MatterArgs, verkey: Uint8Array | null = null) {
+    constructor(
+        { raw, code = MtrDex.X25519, qb64, qb64b, qb2 }: MatterArgs,
+        verkey: Uint8Array | null = null
+    ) {
         if (raw == undefined && verkey != null) {
-            let verfer = new Verfer({qb64b: verkey})
-            if (!Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(verfer.code)) {
-                throw new Error(`Unsupported verkey derivation code = ${verfer.code}.`)
+            const verfer = new Verfer({ qb64b: verkey });
+            if (
+                !Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(
+                    verfer.code
+                )
+            ) {
+                throw new Error(
+                    `Unsupported verkey derivation code = ${verfer.code}.`
+                );
             }
-            raw = libsodium.crypto_sign_ed25519_pk_to_curve25519(verfer.raw)
+            raw = libsodium.crypto_sign_ed25519_pk_to_curve25519(verfer.raw);
         }
 
-        super({raw, code, qb64, qb64b, qb2});
+        super({ raw, code, qb64, qb64b, qb2 });
 
         if (this.code == MtrDex.X25519) {
             this._encrypt = this._x25519;
         } else {
-            throw new Error(`Unsupported encrypter code = ${this.code}.`)
+            throw new Error(`Unsupported encrypter code = ${this.code}.`);
         }
     }
 
     verifySeed(seed: Uint8Array) {
-        let signer = new Signer({qb64b: seed})
-        let keypair = libsodium.crypto_sign_seed_keypair(signer.raw);
-        let pubkey = libsodium.crypto_sign_ed25519_pk_to_curve25519(keypair.publicKey)
-        return arrayEquals(pubkey, this.raw)
+        const signer = new Signer({ qb64b: seed });
+        const keypair = libsodium.crypto_sign_seed_keypair(signer.raw);
+        const pubkey = libsodium.crypto_sign_ed25519_pk_to_curve25519(
+            keypair.publicKey
+        );
+        return arrayEquals(pubkey, this.raw);
     }
 
     encrypt(ser: Uint8Array | null = null, matter: Matter | null = null) {
         if (ser == null && matter == null) {
-            throw new Error("Neither ser nor matter are provided.")
+            throw new Error('Neither ser nor matter are provided.');
         }
 
         if (ser != null) {
-            matter = new Matter({qb64b: ser})
+            matter = new Matter({ qb64b: ser });
         }
 
-        let code
+        let code;
         if (matter!.code == MtrDex.Salt_128) {
-            code = MtrDex.X25519_Cipher_Salt
+            code = MtrDex.X25519_Cipher_Salt;
         } else {
-            code = MtrDex.X25519_Cipher_Seed
+            code = MtrDex.X25519_Cipher_Seed;
         }
 
-        return this._encrypt(matter!.qb64, this.raw, code)
+        return this._encrypt(matter!.qb64, this.raw, code);
     }
 
     _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string) {
-        let raw = libsodium.crypto_box_seal(ser, pubkey)
-        return new Cipher({raw: raw, code: code})
+        const raw = libsodium.crypto_box_seal(ser, pubkey);
+        return new Cipher({ raw: raw, code: code });
     }
-}
+}