signify-ts 0.1.0 → 0.2.0

package/src/keri/core/number.ts

@@ -0,0 +1,66 @@
+import { Matter, MatterArgs, NumDex } from './matter';
+import { bytesToInt, intToBytes } from './utils';
+
+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 bytesToInt(this.raw);
+    }
+
+    get numh(): string {
+        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

@@ -0,0 +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 { blake3 } from '@noble/hashes/blake3';
+
+const Dummy: string = '#';
+
+export class Prefixer extends Matter {
+    private readonly _derive: Function | undefined;
+    private readonly _verify: Function | undefined;
+
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, ked?: Dict<any>) {
+        try {
+            super({ raw, code, qb64b, qb64, qb2 });
+        } catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (ked == undefined || (code == undefined && !('i' in ked))) {
+                    throw e;
+                }
+
+                if (code == undefined) {
+                    super({ qb64: ked['i'], code: code });
+                    code = this.code;
+                }
+
+                let _derive;
+                if (code == MtrDex.Ed25519N) {
+                    _derive = Prefixer._derive_ed25519N;
+                } else if (code == MtrDex.Ed25519) {
+                    _derive = Prefixer._derive_ed25519;
+                } else if (code == MtrDex.Blake3_256) {
+                    _derive = Prefixer._derive_blake3_256;
+                } else {
+                    throw new Error(`Unsupported code = ${code} for prefixer.`);
+                }
+
+                [raw, code] = _derive(ked);
+                super({ raw: raw, code: code });
+                this._derive = _derive;
+            } else {
+                throw e;
+            }
+        }
+
+        if (this.code == MtrDex.Ed25519N) {
+            this._verify = this._verify_ed25519N;
+        } else if (this.code == MtrDex.Ed25519) {
+            this._verify = this._verify_ed25519;
+        } else if (this.code == MtrDex.Blake3_256) {
+            this._verify = this._verify_blake3_256;
+        } else {
+            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`
+            );
+        }
+        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`
+            );
+        }
+        return this._verify!(ked, this.qb64, prefixed);
+    }
+
+    static _derive_ed25519N(ked: Dict<any>): [Uint8Array, string] {
+        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`
+            );
+        }
+        try {
+            verfer = new Verfer({ qb64: keys[0] });
+        } catch (e) {
+            throw new Error(`Error extracting public key = ${e}`);
+        }
+
+        if (!(verfer.code in [MtrDex.Ed25519N])) {
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
+        }
+
+        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}`
+            );
+        }
+
+        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}`
+            );
+        }
+
+        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}`
+            );
+        }
+
+        return [verfer.raw, verfer.code];
+    }
+
+    static _derive_ed25519(ked: Dict<any>): [Uint8Array, string] {
+        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`
+            );
+        }
+
+        try {
+            verfer = new Verfer({ qb64: keys[0] });
+        } catch (e) {
+            throw new Error(`Error extracting public key = ${e}`);
+        }
+
+        if (verfer.code in [MtrDex.Ed25519]) {
+            throw new Error(`Mismatch derivation code = ${verfer.code}`);
+        }
+
+        return [verfer.raw, verfer.code];
+    }
+
+    static _derive_blake3_256(ked: Dict<any>): [Uint8Array, string] {
+        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 {
+        try {
+            const keys = ked['k'];
+            if (keys.length != 1) {
+                return false;
+            }
+
+            if (keys[0] != pre) {
+                return false;
+            }
+
+            if (prefixed && ked['i'] != pre) {
+                return false;
+            }
+
+            const next = 'n' in ked ? ked['n'] : [];
+            if (next.length > 0) {
+                // must be empty
+                return false;
+            }
+        } catch (e) {
+            return false;
+        }
+
+        return true;
+    }
+
+    _verify_ed25519(
+        ked: Dict<any>,
+        pre: string,
+        prefixed: boolean = false
+    ): boolean {
+        try {
+            const keys = ked['k'];
+            if (keys.length != 1) {
+                return false;
+            }
+
+            if (keys[0] != pre) {
+                return false;
+            }
+
+            if (prefixed && ked['i'] != pre) {
+                return false;
+            }
+        } catch (e) {
+            return false;
+        }
+
+        return true;
+    }
+
+    _verify_blake3_256(
+        ked: Dict<any>,
+        pre: string,
+        prefixed: boolean = false
+    ): boolean {
+        try {
+            const [raw] = Prefixer._derive_blake3_256(ked);
+            const crymat = new Matter({ raw: raw, code: MtrDex.Blake3_256 });
+            if (crymat.qb64 != pre) {
+                return false;
+            }
+
+            if (prefixed && ked['i'] != pre) {
+                return false;
+            }
+        } catch (e) {
+            return false;
+        }
+        return true;
+    }
+}

package/src/keri/core/saider.ts

@@ -0,0 +1,186 @@
+import { DigiDex, Matter, MatterArgs, MtrDex } from './matter';
+import { deversify, Dict, Serials } from './core';
+import { EmptyMaterialError } from './kering';
+import { dumps, sizeify } from './serder';
+
+import { blake3 } from '@noble/hashes/blake3';
+
+const Dummy = '#';
+
+export enum Ids {
+    d = 'd',
+}
+
+class Digestage {
+    public klas: any = undefined;
+    public size: number | undefined = 0;
+    public length: number | undefined = 0;
+    constructor(klas: any, size?: number, length?: number) {
+        this.klas = klas;
+        this.size = size;
+        this.length = length;
+    }
+}
+
+export class Saider extends Matter {
+    static Digests = new Map<string, Digestage>([
+        [
+            MtrDex.Blake3_256,
+            new Digestage(Saider._derive_blake3_256, undefined, undefined),
+        ],
+    ]);
+
+    constructor(
+        { raw, code, qb64b, qb64, qb2 }: MatterArgs,
+        sad?: Dict<any>,
+        kind?: Serials,
+        label: string = Ids.d
+    ) {
+        try {
+            super({ raw, code, qb64b, qb64, qb2 });
+        } catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (sad == undefined || !(label in sad)) {
+                    throw e;
+                }
+
+                if (code == undefined) {
+                    if (sad[label] != '') {
+                        super({ qb64: sad[label], code: code });
+                        code = this.code;
+                    } else {
+                        code = MtrDex.Blake3_256;
+                    }
+                }
+
+                if (!DigiDex.has(code)) {
+                    throw new Error(`Unsupported digest code = ${code}`);
+                }
+
+                [raw] = Saider._derive({ ...sad }, code, kind, label);
+                super({ raw: raw, code: code });
+            } else {
+                throw e;
+            }
+        }
+
+        if (!this.digestive) {
+            throw new Error(`Unsupported digest code = ${this.code}.`);
+        }
+    }
+
+    static _derive_blake3_256(
+        ser: Uint8Array,
+        _digest_size: number,
+        _length: number
+    ) {
+        return Buffer.from(blake3.create({ dkLen: 32 }).update(ser).digest());
+    }
+
+    private static _derive(
+        sad: Dict<any>,
+        code: string,
+        kind: Serials | undefined,
+        label: string
+    ): [Uint8Array, Dict<any>] {
+        if (!DigiDex.has(code) || !Saider.Digests.has(code)) {
+            throw new Error(`Unsupported digest code = ${code}.`);
+        }
+
+        sad = { ...sad };
+        sad[label] = ''.padStart(Matter.Sizes.get(code)!.fs!, Dummy);
+        if ('v' in sad) {
+            [, , kind, sad] = sizeify(sad, kind);
+        }
+
+        const ser = { ...sad };
+
+        const digestage = Saider.Digests.get(code);
+
+        const cpa = Saider._serialze(ser, kind);
+        const args: any[] = [];
+        if (digestage!.size != undefined) {
+            args.push(digestage!.size);
+        }
+
+        if (digestage!.length != undefined) {
+            args.push(digestage!.length);
+        }
+
+        return [digestage!.klas(cpa, ...args), sad];
+    }
+
+    public derive(
+        sad: Dict<any>,
+        code: string,
+        kind: Serials | undefined,
+        label: string
+    ): [Uint8Array, Dict<any>] {
+        code = code != undefined ? code : this.code;
+        return Saider._derive(sad, code, kind, label);
+    }
+
+    public verify(
+        sad: Dict<any>,
+        prefixed: boolean = false,
+        versioned: boolean = false,
+        kind?: Serials,
+        label: string = Ids.d
+    ): boolean {
+        try {
+            const [raw, dsad] = Saider._derive(sad, this.code, kind, label);
+            const saider = new Saider({ raw: raw, code: this.code });
+            if (this.qb64 != saider.qb64) {
+                return false;
+            }
+
+            if ('v' in sad && versioned) {
+                if (sad['v'] != dsad['v']) {
+                    return false;
+                }
+            }
+
+            if (prefixed && sad[label] != this.qb64) {
+                return false;
+            }
+        } catch (e) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static _serialze(sad: Dict<any>, kind?: Serials): string {
+        let knd = Serials.JSON;
+        if ('v' in sad) {
+            [, knd] = deversify(sad['v']);
+        }
+
+        if (kind == undefined) {
+            kind = knd;
+        }
+
+        return dumps(sad, kind);
+    }
+
+    public static saidify(
+        sad: Dict<any>,
+        code: string = MtrDex.Blake3_256,
+        kind: Serials = Serials.JSON,
+        label: string = Ids.d
+    ): [Saider, Dict<any>] {
+        if (!(label in sad)) {
+            throw new Error(`Missing id field labeled=${label} in sad.`);
+        }
+        let raw;
+        [raw, sad] = Saider._derive(sad, code, kind, label);
+        const saider = new Saider(
+            { raw: raw, code: code },
+            undefined,
+            kind,
+            label
+        );
+        sad[label] = saider.qb64;
+        return [saider, sad];
+    }
+}