signify-ts 0.1.1 → 0.2.1

package/src/keri/core/number.ts

@@ -1,21 +1,66 @@
+import { Matter, MatterArgs, NumDex } from './matter';
+import { bytesToInt, intToBytes } from './utils';
 
-export class PNumber  {
-    private readonly _num: number = 0;
-    constructor(num?: number | string, numh?: string) {
-        // TODO: Implelment logic
-        if (typeof(num) == "number") {
-            this._num = num
-        } else if (numh != undefined) {
-            this._num = parseInt(numh, 16)
+export class CesrNumber extends Matter {
+    constructor(
+        { raw, code, qb64b, qb64, qb2 }: MatterArgs,
+        num?: number | string,
+        numh?: string
+    ) {
+        let _num;
+        if (
+            raw == undefined &&
+            qb64 == undefined &&
+            qb64b == undefined &&
+            qb2 == undefined
+        ) {
+            if (typeof num == 'number') {
+                _num = num;
+            } else if (numh != undefined) {
+                _num = parseInt(numh, 16);
+            } else {
+                _num = 0;
+            }
         }
 
+        if (_num == undefined) {
+            throw new Error('Invalid whole number');
+        }
+
+        if (_num <= 256 ** 2 - 1) {
+            // make short version of code
+            code = NumDex.Short;
+        } else if (_num <= 256 ** 4 - 1) {
+            // make long version of code
+            code = code = NumDex.Long;
+        } else if (_num <= 256 ** 8 - 1) {
+            // make big version of code
+            code = code = NumDex.Big;
+        } else if (_num <= 256 ** 16 - 1) {
+            // make huge version of code
+            code = code = NumDex.Huge;
+        } else {
+            throw new Error('Invalid num = {num}, too large to encode.');
+        }
+
+        raw = intToBytes(_num, Matter._rawSize(code));
+
+        super({ raw, code, qb64b, qb64, qb2 });
+
+        if (!NumDex.has(this.code)) {
+            throw new Error('Invalid code ' + code + ' for Number');
+        }
     }
 
     get num(): number {
-        return this._num;
+        return bytesToInt(this.raw);
     }
 
     get numh(): string {
-        return this._num.toString(16)
+        return this.num.toString(16);
+    }
+
+    get positive(): boolean {
+        return this.num > 0;
     }
-}
+}

package/src/keri/core/pather.ts

@@ -0,0 +1,98 @@
+import { Bexter, Reb64 } from './bexter';
+import { MatterArgs, MtrDex } from './matter';
+import { EmptyMaterialError } from './kering';
+
+/*
+    Pather is a subclass of Bexter that provides SAD Path language specific functionality
+    for variable length strings that only contain Base64 URL safe characters.  Pather allows
+    the specification of SAD Paths as a list of field components which will be converted to the
+    Base64 URL safe character representation.
+
+    Additionally, Pather provides .rawify for extracting and serializing the content targeted by
+    .path for a SAD, represented as an instance of Serder.  Pather enforces Base64 URL character
+    safety by leveraging the fact that SADs must have static field ordering.  Any field label can
+    be replaced by its field ordinal to allow for path specification and traversal for any field
+    labels that contain non-Base64 URL safe characters.
+
+
+    Examples: strings:
+        path = []
+        text = "-"
+        qb64 = '6AABAAA-'
+
+        path = ["A"]
+        text = "-A"
+        qb64 = '5AABAA-A'
+
+        path = ["A", "B"]
+        text = "-A-B"
+        qb64 = '4AAB-A-B'
+
+        path = ["A", 1, "B", 3]
+        text = "-A-1-B-3"
+        qb64 = '4AAC-A-1-B-3'
+
+ */
+
+export class Pather extends Bexter {
+    constructor(
+        { raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }: MatterArgs,
+        bext?: string,
+        path?: string[]
+    ) {
+        if (
+            raw === undefined &&
+            bext === undefined &&
+            qb64b === undefined &&
+            qb64 === undefined &&
+            qb2 === undefined
+        ) {
+            if (path === undefined)
+                throw new EmptyMaterialError('Missing bext string.');
+
+            bext = Pather._bextify(path);
+        }
+
+        super({ raw, code, qb64b, qb64, qb2 }, bext);
+    }
+
+    // TODO: implement SAD access methods like resolve, root, strip, startswith and tail
+
+    get path(): string[] {
+        if (!this.bext.startsWith('-')) {
+            throw new Error('invalid SAD ptr');
+        }
+
+        let path = this.bext;
+        while (path.charAt(0) === '-') {
+            path = path.substring(1);
+        }
+
+        const apath = path.split('-');
+        if (apath[0] !== '') {
+            return apath;
+        } else {
+            return [];
+        }
+    }
+
+    static _bextify(path: any[]): string {
+        const vath = [];
+        for (const p of path) {
+            let sp = '';
+            if (typeof p === 'number') {
+                sp = p.toString();
+            } else {
+                sp = p;
+            }
+
+            const match = Reb64.exec(sp);
+            if (!match) {
+                throw new Error(`"Non Base64 path component = ${p}.`);
+            }
+
+            vath.push(sp);
+        }
+        return '-' + vath.join('-');
+    }
+}

package/src/keri/core/prefixer.ts

@@ -1,212 +1,233 @@
-import {Matter, MatterArgs, MtrDex} from "./matter";
-import {EmptyMaterialError} from "./kering";
-import {Dict, Ilks} from "./core";
-import {sizeify} from "./serder";
-import {Verfer} from "./verfer";
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { EmptyMaterialError } from './kering';
+import { Dict, Ilks } from './core';
+import { sizeify } from './serder';
+import { Verfer } from './verfer';
 
-import {createHash} from "blake3"
-
-const Dummy: string = "#"
+import { blake3 } from '@noble/hashes/blake3';
 
+const Dummy: string = '#';
 
 export class Prefixer extends Matter {
-    private readonly _derive: Function | undefined
-    private readonly _verify: Function | undefined
+    private readonly _derive: Function | undefined;
+    private readonly _verify: Function | undefined;
 
-    constructor({raw, code, qb64b, qb64, qb2}: MatterArgs, ked?: Dict<any>) {
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, ked?: Dict<any>) {
         try {
-            super({raw, code, qb64b, qb64, qb2});
+            super({ raw, code, qb64b, qb64, qb2 });
         } catch (e) {
             if (e instanceof EmptyMaterialError) {
-                if (ked == undefined || (code == undefined && !("i" in ked))) {
-                    throw e
+                if (ked == undefined || (code == undefined && !('i' in ked))) {
+                    throw e;
                 }
 
                 if (code == undefined) {
-                    super({qb64: ked['i'], code: code})
-                    code = this.code
+                    super({ qb64: ked['i'], code: code });
+                    code = this.code;
                 }
 
-                let _derive
+                let _derive;
                 if (code == MtrDex.Ed25519N) {
-                    _derive = Prefixer._derive_ed25519N
+                    _derive = Prefixer._derive_ed25519N;
                 } else if (code == MtrDex.Ed25519) {
-                    _derive = Prefixer._derive_ed25519
+                    _derive = Prefixer._derive_ed25519;
                 } else if (code == MtrDex.Blake3_256) {
-                    _derive = Prefixer._derive_blake3_256
+                    _derive = Prefixer._derive_blake3_256;
                 } else {
-                    throw new Error(`Unsupported code = ${code} for prefixer.`)
+                    throw new Error(`Unsupported code = ${code} for prefixer.`);
                 }
 
-                [raw, code] = _derive(ked)
-                super({raw: raw, code: code})
-                this._derive = _derive
+                [raw, code] = _derive(ked);
+                super({ raw: raw, code: code });
+                this._derive = _derive;
             } else {
-                throw e
+                throw e;
             }
         }
 
         if (this.code == MtrDex.Ed25519N) {
-            this._verify = this._verify_ed25519N
+            this._verify = this._verify_ed25519N;
         } else if (this.code == MtrDex.Ed25519) {
-            this._verify = this._verify_ed25519
+            this._verify = this._verify_ed25519;
         } else if (this.code == MtrDex.Blake3_256) {
-            this._verify = this._verify_blake3_256
+            this._verify = this._verify_blake3_256;
         } else {
-            throw new Error(`Unsupported code = ${code} for prefixer.`)
+            throw new Error(`Unsupported code = ${code} for prefixer.`);
         }
-
     }
 
     derive(ked: Dict<any>): [Uint8Array, string] {
-        if (ked["i"] != Ilks.icp) {
-            throw new Error(`Non-incepting ilk ${ked['i']} for prefix derivation`)
+        if (ked['i'] != Ilks.icp) {
+            throw new Error(
+                `Non-incepting ilk ${ked['i']} for prefix derivation`
+            );
         }
-        return this._derive!(ked)
+        return this._derive!(ked);
     }
 
     verify(ked: Dict<any>, prefixed: boolean = false): boolean {
-        if (ked["i"] != Ilks.icp) {
-            throw new Error(`Non-incepting ilk ${ked['i']} for prefix derivation`)
+        if (ked['i'] != Ilks.icp) {
+            throw new Error(
+                `Non-incepting ilk ${ked['i']} for prefix derivation`
+            );
         }
-        return this._verify!(ked, this.qb64, prefixed)
+        return this._verify!(ked, this.qb64, prefixed);
     }
 
-
     static _derive_ed25519N(ked: Dict<any>): [Uint8Array, string] {
-        let verfer
-        let keys = ked["k"]
+        let verfer;
+        const keys = ked['k'];
         if (keys.length != 1) {
-            throw new Error(`Basic derivation needs at most 1 key got ${keys.length} keys instead`)
+            throw new Error(
+                `Basic derivation needs at most 1 key got ${keys.length} keys instead`
+            );
         }
         try {
-            verfer = new Verfer({qb64: keys[0]})
+            verfer = new Verfer({ qb64: keys[0] });
         } catch (e) {
-            throw new Error(`Error extracting public key = ${e}`)
+            throw new Error(`Error extracting public key = ${e}`);
         }
 
         if (!(verfer.code in [MtrDex.Ed25519N])) {
-            throw new Error(`Mismatch derivation code = ${verfer.code}`)
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
         }
 
-        let next = 'n' in ked ? ked['n'] : []
+        const next = 'n' in ked ? ked['n'] : [];
         if (verfer.code == MtrDex.Ed25519N && next.length > 0) {
-            throw new Error(`Non-empty nxt = ${next} for non-transferable code = ${verfer.code}`)
+            throw new Error(
+                `Non-empty nxt = ${next} for non-transferable code = ${verfer.code}`
+            );
         }
 
-        let backers = 'b' in ked ? ked['b'] : []
+        const backers = 'b' in ked ? ked['b'] : [];
         if (verfer.code == MtrDex.Ed25519N && backers.length > 0) {
-            throw new Error(`Non-empty b =${backers} for non-transferable code = ${verfer.code}`)
+            throw new Error(
+                `Non-empty b =${backers} for non-transferable code = ${verfer.code}`
+            );
         }
 
-        let anchor = 'a' in ked ? ked['a'] : []
+        const anchor = 'a' in ked ? ked['a'] : [];
         if (verfer.code == MtrDex.Ed25519N && anchor.length > 0) {
-            throw new Error(`Non-empty a = ${verfer.code} for non-transferable code = ${verfer.code}`)
+            throw new Error(
+                `Non-empty a = ${verfer.code} for non-transferable code = ${verfer.code}`
+            );
         }
 
-        return [verfer.raw, verfer.code]
-
+        return [verfer.raw, verfer.code];
     }
 
     static _derive_ed25519(ked: Dict<any>): [Uint8Array, string] {
-        let verfer
-        let keys = ked["k"]
+        let verfer;
+        const keys = ked['k'];
         if (keys.length != 1) {
-            throw new Error(`Basic derivation needs at most 1 key got ${keys.length} keys instead`)
+            throw new Error(
+                `Basic derivation needs at most 1 key got ${keys.length} keys instead`
+            );
         }
 
         try {
-            verfer = new Verfer({qb64: keys[0]})
+            verfer = new Verfer({ qb64: keys[0] });
         } catch (e) {
-            throw new Error(`Error extracting public key = ${e}`)
+            throw new Error(`Error extracting public key = ${e}`);
         }
 
         if (verfer.code in [MtrDex.Ed25519]) {
-            throw new Error(`Mismatch derivation code = ${verfer.code}`)
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
         }
 
-        return [verfer.raw, verfer.code]
+        return [verfer.raw, verfer.code];
     }
 
     static _derive_blake3_256(ked: Dict<any>): [Uint8Array, string] {
-        let kd = ked
-        let ilk = ked["t"]
-        if (ilk != Ilks.icp) {
-            throw new Error(`Invalid ilk = ${ilk} to derive pre.`)
-        }
-
-        kd["i"] = "".padStart(Matter.Sizes.get(MtrDex.Blake3_256)!.fs, Dummy)
-        kd["d"] = ked["i"]
-        let [raw] = sizeify(ked)
-        const hasher = createHash();
-        const dig = hasher.update(raw).digest('');
-        return [dig, MtrDex.Blake3_256]
+        const kd = ked;
+        const ilk = ked['t'];
+        if (![Ilks.icp, Ilks.dip, Ilks.vcp, Ilks.dip].includes(ilk)) {
+            throw new Error(`Invalid ilk = ${ilk} to derive pre.`);
+        }
+
+        kd['i'] = ''.padStart(Matter.Sizes.get(MtrDex.Blake3_256)!.fs!, Dummy);
+        kd['d'] = ked['i'];
+        const [raw] = sizeify(ked);
+        const dig = Buffer.from(
+            blake3.create({ dkLen: 32 }).update(raw).digest()
+        );
+        return [dig, MtrDex.Blake3_256];
     }
 
-    _verify_ed25519N(ked: Dict<any>, pre: string, prefixed: boolean = false): boolean {
+    _verify_ed25519N(
+        ked: Dict<any>,
+        pre: string,
+        prefixed: boolean = false
+    ): boolean {
         try {
-            let keys = ked["k"]
+            const keys = ked['k'];
             if (keys.length != 1) {
-                return false
+                return false;
             }
 
             if (keys[0] != pre) {
-                return false
+                return false;
             }
 
-            if (prefixed && ked["i"] != pre) {
-                return false
+            if (prefixed && ked['i'] != pre) {
+                return false;
             }
 
-            let next = 'n' in ked ? ked['n'] : []
-            if (next.length > 0) { // must be empty
-                return false
+            const next = 'n' in ked ? ked['n'] : [];
+            if (next.length > 0) {
+                // must be empty
+                return false;
             }
         } catch (e) {
-            return false
+            return false;
         }
 
-        return true
-
+        return true;
     }
 
-    _verify_ed25519(ked: Dict<any>, pre: string, prefixed: boolean = false): boolean {
+    _verify_ed25519(
+        ked: Dict<any>,
+        pre: string,
+        prefixed: boolean = false
+    ): boolean {
         try {
-            let keys = ked["k"]
+            const keys = ked['k'];
             if (keys.length != 1) {
-                return false
+                return false;
             }
 
             if (keys[0] != pre) {
-                return false
+                return false;
             }
 
-            if (prefixed && ked["i"] != pre) {
-                return false
+            if (prefixed && ked['i'] != pre) {
+                return false;
             }
         } catch (e) {
-            return false
+            return false;
         }
 
-        return true
+        return true;
     }
 
-    _verify_blake3_256(ked: Dict<any>, pre: string, prefixed: boolean = false): boolean {
+    _verify_blake3_256(
+        ked: Dict<any>,
+        pre: string,
+        prefixed: boolean = false
+    ): boolean {
         try {
-            let [raw,] = Prefixer._derive_blake3_256(ked)
-            let crymat = new Matter({raw: raw, code: MtrDex.Blake3_256})
+            const [raw] = Prefixer._derive_blake3_256(ked);
+            const crymat = new Matter({ raw: raw, code: MtrDex.Blake3_256 });
             if (crymat.qb64 != pre) {
-                return false
+                return false;
             }
 
-            if (prefixed && ked["i"] != pre) {
-                return false
+            if (prefixed && ked['i'] != pre) {
+                return false;
             }
-
         } catch (e) {
-            return false
+            return false;
         }
-        return true
-
+        return true;
     }
-}
+}