signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/dist/keri/core/counter.js

@@ -0,0 +1,221 @@
+import { Codex, Sizage } from "./matter.js";
+import { b, b64ToInt, d, intToB64 } from "./core.js";
+export class CounterCodex extends Codex {
+    constructor() {
+        super(...arguments);
+        this.ControllerIdxSigs = '-A'; // Qualified Base64 Indexed Signature.
+        this.WitnessIdxSigs = '-B'; // Qualified Base64 Indexed Signature.
+        this.NonTransReceiptCouples = '-C'; // Composed Base64 Couple, pre+cig.
+        this.TransReceiptQuadruples = '-D'; // Composed Base64 Quadruple, pre+snu+dig+sig.
+        this.FirstSeenReplayCouples = '-E'; // Composed Base64 Couple, fnu+dts.
+        this.TransIdxSigGroups = '-F'; // Composed Base64 Group, pre+snu+dig+ControllerIdxSigs group.
+        this.SealSourceCouples = '-G'; // Composed Base64 couple, snu+dig of given delegators or issuers event
+        this.TransLastIdxSigGroups = '-H'; // Composed Base64 Group, pre+ControllerIdxSigs group.
+        this.SealSourceTriples = '-I'; // Composed Base64 triple, pre+snu+dig of anchoring source event
+        this.SadPathSig = '-J'; // Composed Base64 Group path+TransIdxSigGroup of SAID of content
+        this.SadPathSigGroup = '-K'; // Composed Base64 Group, root(path)+SaidPathCouples
+        this.PathedMaterialQuadlets = '-L'; // Composed Grouped Pathed Material Quadlet (4 char each)
+        this.AttachedMaterialQuadlets = '-V'; // Composed Grouped Attached Material Quadlet (4 char each)
+        this.BigAttachedMaterialQuadlets = '-0V'; // Composed Grouped Attached Material Quadlet (4 char each)
+        this.KERIProtocolStack = '--AAA'; // KERI ACDC Protocol Stack CESR Version
+    }
+}
+export const CtrDex = new CounterCodex();
+export class Counter {
+    constructor({ code, count, countB64, qb64b, qb64, qb2 }) {
+        this._code = '';
+        this._count = -1;
+        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() {
+        return this._code;
+    }
+    get count() {
+        return this._count;
+    }
+    get qb64() {
+        return this._infil();
+    }
+    get qb64b() {
+        return b(this.qb64);
+    }
+    countToB64(l) {
+        if (l == undefined) {
+            const sizage = Counter.Sizes.get(this.code);
+            l = sizage.ss;
+        }
+        return intToB64(this.count, l);
+    }
+    static semVerToB64(version = '', major = 0, minor = 0, patch = 0) {
+        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('');
+    }
+    _infil() {
+        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;
+    }
+    _exfil(qb64) {
+        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;
+    }
+}
+Counter.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),
+}));
+Counter.Hards = new Map([
+    ['-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],
+]);

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

@@ -1,7 +1,7 @@
-import { Matter, MatterArgs } from './matter';
-import { Signer } from './signer';
-import { Cipher } from './cipher';
-import { Salter } from './salter';
+import { Matter, MatterArgs } from './matter.ts';
+import { Signer } from './signer.ts';
+import { Cipher } from './cipher.ts';
+import { Salter } from './salter.ts';
 export declare class Decrypter extends Matter {
     private readonly _decrypt;
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, seed?: Uint8Array | undefined);

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

@@ -1,79 +1,62 @@
 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 { Matter, MtrDex } from "./matter.js";
+import { Signer } from "./signer.js";
+import { Cipher } from "./cipher.js";
+import { EmptyMaterialError } from "./kering.js";
+import { Salter } from "./salter.js";
 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 }, seed = undefined) {
         try {
             super({ raw, code, qb64, qb64b, qb2 });
-        } catch (e) {
+        }
+        catch (e) {
             if (e instanceof EmptyMaterialError) {
                 if (seed != undefined) {
                     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}`);
                     }
-                    const sigkey = new Uint8Array(
-                        signer.raw.length + signer.verfer.raw.length
-                    );
+                    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 {
+                }
+                else {
                     throw e;
                 }
-            } else {
+            }
+            else {
                 throw e;
             }
         }
-
         if (this.code == MtrDex.X25519_Private) {
             this._decrypt = this._x25519;
-        } else {
+        }
+        else {
             throw new Error(`Unsupported decrypter code = ${this.code}.`);
         }
     }
-
-    decrypt(
-        ser: Uint8Array | null = null,
-        cipher: Cipher | null = null,
-        transferable: boolean = false
-    ) {
+    decrypt(ser = null, cipher = null, transferable = false) {
         if (ser == null && cipher == null) {
             throw new EmptyMaterialError('Neither ser or cipher were provided');
         }
-
         if (ser != null) {
             cipher = new Cipher({ qb64b: ser });
         }
-
         return this._decrypt(cipher, this.raw, transferable);
     }
-
-    _x25519(cipher: Cipher, prikey: Uint8Array, transferable: boolean = false) {
+    _x25519(cipher, prikey, transferable = false) {
         const pubkey = libsodium.crypto_scalarmult_base(prikey);
-        const plain = libsodium.crypto_box_seal_open(
-            cipher.raw,
-            pubkey,
-            prikey
-        );
+        const plain = libsodium.crypto_box_seal_open(cipher.raw, pubkey, prikey);
         if (cipher.code == MtrDex.X25519_Cipher_Salt) {
             return new Salter({ qb64b: plain });
-        } else if (cipher.code == MtrDex.X25519_Cipher_Seed) {
+        }
+        else if (cipher.code == MtrDex.X25519_Cipher_Seed) {
             return new Signer({ qb64b: plain, transferable: transferable });
-        } else {
+        }
+        else {
             throw new Error(`Unsupported cipher text code == ${cipher.code}`);
         }
     }

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

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 /**
  * @description : Diger is subset of Matter and is used to verify the digest of serialization
  * It uses  .raw : as digest
@@ -16,6 +16,6 @@ export declare class Diger extends Matter {
      by .code
      */
     verify(ser: Uint8Array): boolean;
-    compare(ser: Uint8Array, dig?: any, diger?: Diger | null): boolean;
-    blake3_256(ser: Uint8Array, dig: any): boolean;
+    compare(ser: Uint8Array, dig?: Uint8Array | null, diger?: Diger | null): boolean;
+    blake3_256(ser: Uint8Array, dig: Uint8Array): boolean;
 }

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

@@ -1,46 +1,36 @@
 import { blake3 } from '@noble/hashes/blake3';
-
-import { Matter, MatterArgs, MtrDex } from './matter';
-
+import { Matter, MtrDex } from "./matter.js";
 /**
  * @description : Diger is subset of Matter and is used to verify the digest of serialization
  * It uses  .raw : as digest
  * .code as digest algorithm
  *
  */
-
 export class Diger extends Matter {
-    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 }, ser = null) {
         try {
             super({ raw, code, qb64, qb64b, qb2 });
-        } catch (error) {
+        }
+        catch (error) {
             if (ser == null) {
                 throw error;
             }
-
             if (code === MtrDex.Blake3_256) {
-                const dig = Buffer.from(
-                    blake3.create({ dkLen: 32 }).update(ser).digest()
-                );
+                const dig = blake3.create({ dkLen: 32 }).update(ser).digest();
                 super({ raw: dig, code: code });
-            } else {
+            }
+            else {
                 throw new Error(`Unsupported code = ${code} for digester.`);
             }
         }
-
         if (code === MtrDex.Blake3_256) {
             this._verify = this.blake3_256;
-        } else {
+        }
+        else {
             throw new Error(`Unsupported code = ${code} for digester.`);
         }
     }
-
     /**
      *
      * @param {Uint8Array} ser  serialization bytes
@@ -48,36 +38,31 @@ export class Diger extends Matter {
      * using .raw as reference digest for ._verify digest algorithm determined
      by .code
      */
-    verify(ser: Uint8Array): boolean {
+    verify(ser) {
         return this._verify(ser, this.raw);
     }
-
-    compare(ser: Uint8Array, dig: any = null, diger: Diger | null = null) {
+    compare(ser, dig = null, diger = null) {
         if (dig != null) {
             if (dig.toString() == this.qb64) {
                 return true;
             }
-
             diger = new Diger({ qb64b: dig });
-        } else if (diger != null) {
+        }
+        else if (diger != null) {
             if (diger.qb64b == this.qb64b) {
                 return true;
             }
-        } else {
+        }
+        else {
             throw new Error('Both dig and diger may not be None.');
         }
-
         if (diger.code == this.code) {
             return false;
         }
-
         return diger.verify(ser) && this.verify(ser);
     }
-
-    blake3_256(ser: Uint8Array, dig: any) {
-        const digest = Buffer.from(
-            blake3.create({ dkLen: 32 }).update(ser).digest()
-        );
-        return digest.toString() === dig.toString();
+    blake3_256(ser, dig) {
+        const digest = blake3.create({ dkLen: 32 }).update(ser).digest();
+        return (digest.length == dig.length && digest.toString() === dig.toString());
     }
 }

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

@@ -1,5 +1,5 @@
-import { Matter, MatterArgs } from './matter';
-import { Cipher } from './cipher';
+import { Matter, MatterArgs } from './matter.ts';
+import { Cipher } from './cipher.ts';
 export declare class Encrypter extends Matter {
     private _encrypt;
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verkey?: Uint8Array | null);

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

@@ -1,69 +1,49 @@
 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 { Matter, MtrDex } from "./matter.js";
+import { Verfer } from "./verfer.js";
+import { Signer } from "./signer.js";
+import { Cipher } from "./cipher.js";
+import { arrayEquals } from "./utils.js";
 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 }, verkey = null) {
         if (raw == undefined && verkey != null) {
             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}.`
-                );
+            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);
         }
-
         super({ raw, code, qb64, qb64b, qb2 });
-
         if (this.code == MtrDex.X25519) {
             this._encrypt = this._x25519;
-        } else {
+        }
+        else {
             throw new Error(`Unsupported encrypter code = ${this.code}.`);
         }
     }
-
-    verifySeed(seed: Uint8Array) {
+    verifySeed(seed) {
         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
-        );
+        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) {
+    encrypt(ser = null, matter = null) {
         if (ser == null && matter == null) {
             throw new Error('Neither ser nor matter are provided.');
         }
-
         if (ser != null) {
             matter = new Matter({ qb64b: ser });
         }
-
         let code;
-        if (matter!.code == MtrDex.Salt_128) {
+        if (matter.code == MtrDex.Salt_128) {
             code = MtrDex.X25519_Cipher_Salt;
-        } else {
+        }
+        else {
             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) {
+    _x25519(ser, pubkey, code) {
         const raw = libsodium.crypto_box_seal(ser, pubkey);
         return new Cipher({ raw: raw, code: code });
     }

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

@@ -1,7 +1,7 @@
-import { Serials, Version } from './core';
-import { Serder } from './serder';
-import { Siger } from './siger';
-import { Cigar } from './cigar';
+import { Serials, Version } from './core.ts';
+import { Serder } from './serder.ts';
+import { Siger } from './siger.ts';
+import { Cigar } from './cigar.ts';
 export interface RotateArgs {
     pre?: string;
     keys: Array<string>;
@@ -26,9 +26,9 @@ export declare function rotate({ pre, keys, dig, ilk, sn, isith, ndigs, nsith, w
 export declare function ample(n: number, f?: number, weak?: boolean): number;
 export interface InceptArgs {
     keys: Array<string>;
-    isith?: number | string | Array<string>;
+    isith?: string | number | string[] | string[][];
     ndigs?: Array<string>;
-    nsith?: number | string | Array<string>;
+    nsith?: string | number | string[] | string[][];
     toad?: number | string;
     wits?: Array<string>;
     cnfg?: Array<string>;