signify-ts 0.2.1 → 0.3.0-rc2

package/src/keri/core/prefixer.ts

@@ -1,233 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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];
-    }
-}

package/src/keri/core/salter.ts

@@ -1,120 +0,0 @@
-import { Signer } from './signer';
-
-import { Matter, MtrDex } from './matter';
-import { EmptyMaterialError } from './kering';
-import libsodium from 'libsodium-wrappers-sumo';
-
-export enum Tier {
-    low = 'low',
-    med = 'med',
-    high = 'high',
-}
-
-interface SalterArgs {
-    raw?: Uint8Array | undefined;
-    code?: string;
-    tier?: Tier;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string;
-    qb2?: Uint8Array | undefined;
-}
-export class Salter extends Matter {
-    private readonly _tier: Tier | null;
-
-    constructor({
-        raw,
-        code = MtrDex.Salt_128,
-        tier = Tier.low,
-        qb64,
-        qb64b,
-        qb2,
-    }: SalterArgs) {
-        try {
-            super({ raw, code, qb64, qb64b, qb2 });
-        } catch (e) {
-            if (e instanceof EmptyMaterialError) {
-                if (code == MtrDex.Salt_128) {
-                    const salt = libsodium.randombytes_buf(
-                        libsodium.crypto_pwhash_SALTBYTES
-                    );
-                    super({ raw: salt, code: code });
-                } else {
-                    throw new Error(
-                        'invalid code for Salter, only Salt_128 accepted'
-                    );
-                }
-            } else {
-                throw e;
-            }
-        }
-
-        if (this.code != MtrDex.Salt_128) {
-            throw new Error('invalid code for Salter, only Salt_128 accepted');
-        }
-
-        this._tier = tier !== null ? tier : Tier.low;
-    }
-
-    private stretch(
-        size: number = 32,
-        path: string = '',
-        tier: Tier | null = null,
-        temp: boolean = false
-    ): Uint8Array {
-        tier = tier == null ? this.tier : tier;
-
-        let opslimit: number, memlimit: number;
-
-        // Harcoded values based on keripy
-        if (temp) {
-            opslimit = 1; //libsodium.crypto_pwhash_OPSLIMIT_MIN
-            memlimit = 8192; //libsodium.crypto_pwhash_MEMLIMIT_MIN
-        } else {
-            switch (tier) {
-                case Tier.low:
-                    opslimit = 2; //libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE
-                    memlimit = 67108864; //libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE
-                    break;
-                case Tier.med:
-                    opslimit = 3; //libsodium.crypto_pwhash_OPSLIMIT_MODERATE
-                    memlimit = 268435456; //libsodium.crypto_pwhash_MEMLIMIT_MODERATE
-                    break;
-                case Tier.high:
-                    opslimit = 4; //libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE
-                    memlimit = 1073741824; //libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE
-                    break;
-                default:
-                    throw new Error(`Unsupported security tier = ${tier}.`);
-            }
-        }
-
-        return libsodium.crypto_pwhash(
-            size,
-            path,
-            this.raw,
-            opslimit,
-            memlimit,
-            libsodium.crypto_pwhash_ALG_ARGON2ID13
-        );
-    }
-
-    signer(
-        code: string = MtrDex.Ed25519_Seed,
-        transferable: boolean = true,
-        path: string = '',
-        tier: Tier | null = null,
-        temp: boolean = false
-    ): Signer {
-        const seed = this.stretch(Matter._rawSize(code), path, tier, temp);
-
-        return new Signer({
-            raw: seed,
-            code: code,
-            transferable: transferable,
-        });
-    }
-
-    get tier(): Tier | null {
-        return this._tier;
-    }
-}

package/src/keri/core/serder.ts

@@ -1,163 +0,0 @@
-import { MtrDex } from './matter';
-import {
-    deversify,
-    Dict,
-    Ident,
-    Serials,
-    versify,
-    Version,
-    Versionage,
-} from './core';
-import { Verfer } from './verfer';
-import { Diger } from './diger';
-import { CesrNumber } from './number';
-
-export class Serder {
-    private _kind: Serials;
-    private _raw: string = '';
-    private _ked: Dict<any> = {};
-    private _ident: Ident = Ident.KERI;
-    private _size: number = 0;
-    private _version: Version = Versionage;
-    private readonly _code: string;
-
-    constructor(
-        ked: Dict<any>,
-        kind: Serials = Serials.JSON,
-        code: string = MtrDex.Blake3_256
-    ) {
-        this._code = code;
-        this._kind = kind;
-        this.ked = ked;
-    }
-
-    set ked(ked: Dict<any>) {
-        const [raw, ident, kind, kd, version] = this._exhale(ked, this._kind);
-        const size = raw.length;
-        this._raw = raw;
-        this._ident = ident;
-        this._ked = kd;
-        this._kind = kind;
-        this._size = size;
-        this._version = version;
-    }
-
-    get pre(): string {
-        return this._ked['i'];
-    }
-
-    get ked(): Dict<any> {
-        return this._ked;
-    }
-
-    get code(): string {
-        return this._code;
-    }
-
-    get raw(): string {
-        return this._raw;
-    }
-
-    get sner(): CesrNumber {
-        return new CesrNumber({}, this.ked['s']);
-    }
-
-    get sn(): number {
-        return this.sner.num;
-    }
-
-    get kind(): Serials {
-        return this._kind;
-    }
-
-    private _exhale(
-        ked: Dict<any>,
-        kind: Serials
-    ): [string, Ident, Serials, Dict<any>, Version] {
-        return sizeify(ked, kind);
-    }
-
-    get ident(): Ident {
-        return this._ident;
-    }
-
-    get size(): number {
-        return this._size;
-    }
-
-    get version(): Version {
-        return this._version;
-    }
-    get verfers(): Verfer[] {
-        let keys: any = [];
-        if ('k' in this._ked) {
-            // establishment event
-            keys = this._ked['k'];
-        } else {
-            // non-establishment event
-            keys = [];
-        }
-        // create a new Verfer for each key
-        const verfers = [];
-        for (const key of keys) {
-            verfers.push(new Verfer({ qb64: key }));
-        }
-        return verfers;
-    }
-
-    get digers(): Diger[] {
-        let keys: any = [];
-        if ('n' in this._ked) {
-            // establishment event
-            keys = this._ked['n'];
-        } else {
-            // non-establishment event
-            keys = [];
-        }
-        // create a new Verfer for each key
-        const digers = [];
-        for (const key of keys) {
-            digers.push(new Diger({ qb64: key }));
-        }
-        return digers;
-    }
-
-    pretty() {
-        return JSON.stringify(this._ked, undefined, 2);
-    }
-}
-
-export function dumps(ked: Object, kind: Serials.JSON): string {
-    if (kind == Serials.JSON) {
-        return JSON.stringify(ked);
-    } else {
-        throw new Error('unsupported event encoding');
-    }
-}
-
-export function sizeify(
-    ked: Dict<any>,
-    kind?: Serials
-): [string, Ident, Serials, Dict<any>, Version] {
-    if (!('v' in ked)) {
-        throw new Error('Missing or empty version string');
-    }
-
-    const [ident, knd, version] = deversify(ked['v'] as string);
-    if (version != Versionage) {
-        throw new Error(`unsupported version ${version.toString()}`);
-    }
-
-    if (kind == undefined) {
-        kind = knd;
-    }
-
-    let raw = dumps(ked, kind);
-    const size = raw.length;
-
-    ked['v'] = versify(ident, version, kind, size);
-
-    raw = dumps(ked, kind);
-
-    return [raw, ident, kind, ked, version];
-}