signify-ts 0.1.1 → 0.2.0

package/src/keri/core/saider.ts

@@ -1,158 +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 { DigiDex, Matter, MatterArgs, MtrDex } from './matter';
+import { deversify, Dict, Serials } from './core';
+import { EmptyMaterialError } from './kering';
+import { dumps, sizeify } from './serder';
 
-import {createHash} from "blake3"
+import { blake3 } from '@noble/hashes/blake3';
 
-const Dummy = "#"
+const Dummy = '#';
 
 export enum Ids {
-    d = "d"
+    d = 'd',
 }
 
 class Digestage {
-    public klas: any = undefined
-    public size: number | undefined = 0
-    public length: number | undefined = 0
+    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
+        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) {
+        [
+            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});
+            super({ raw, code, qb64b, qb64, qb2 });
         } catch (e) {
             if (e instanceof EmptyMaterialError) {
                 if (sad == undefined || !(label in sad)) {
-                    throw e
+                    throw e;
                 }
 
                 if (code == undefined) {
-                    if (sad[label] != "") {
-                        super({qb64: sad[label], code: code})
-                        code = this.code
+                    if (sad[label] != '') {
+                        super({ qb64: sad[label], code: code });
+                        code = this.code;
                     } else {
-                        code = MtrDex.Blake3_256
+                        code = MtrDex.Blake3_256;
                     }
                 }
 
                 if (!DigiDex.has(code)) {
-                    throw new Error(`Unsupported digest code = ${code}`)
+                    throw new Error(`Unsupported digest code = ${code}`);
                 }
 
-                [raw] = Saider._derive({...sad}, code, kind, label)
-                super({raw: raw, code: code})
+                [raw] = Saider._derive({ ...sad }, code, kind, label);
+                super({ raw: raw, code: code });
             } else {
-                throw e
+                throw e;
             }
         }
 
         if (!this.digestive) {
-            throw new Error(`Unsupported digest code = ${this.code}.`)
+            throw new Error(`Unsupported digest code = ${this.code}.`);
         }
-
     }
 
-    static _derive_blake3_256(ser: Uint8Array, _digest_size: number, _length: number) {
-        const hasher = createHash();
-        return hasher.update(ser).digest('');
+    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>] {
+    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}.`)
+            throw new Error(`Unsupported digest code = ${code}.`);
         }
 
-        sad = {...sad}
-        sad[label] = "".padStart(Matter.Sizes.get(code)!.fs, Dummy)
+        sad = { ...sad };
+        sad[label] = ''.padStart(Matter.Sizes.get(code)!.fs!, Dummy);
         if ('v' in sad) {
-            [, , kind, sad, ] = sizeify(sad, kind)
+            [, , kind, sad] = sizeify(sad, kind);
         }
 
-        let ser = {...sad}
+        const ser = { ...sad };
 
-        let digestage = Saider.Digests.get(code)
+        const digestage = Saider.Digests.get(code);
 
-        let cpa = Saider._serialze(ser, kind)
-        let args: any[] = []
+        const cpa = Saider._serialze(ser, kind);
+        const args: any[] = [];
         if (digestage!.size != undefined) {
-            args.push(digestage!.size)
+            args.push(digestage!.size);
         }
 
         if (digestage!.length != undefined) {
-            args.push(digestage!.length)
+            args.push(digestage!.length);
         }
 
-        return [digestage!.klas(cpa, ...args), sad]
+        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 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 {
+    public verify(
+        sad: Dict<any>,
+        prefixed: boolean = false,
+        versioned: boolean = false,
+        kind?: Serials,
+        label: string = Ids.d
+    ): boolean {
         try {
-            let [raw, dsad] = Saider._derive(sad, this.code, kind, label)
-            let saider = new Saider({raw: raw, code: this.code})
+            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
+                return false;
             }
 
-            if ("v" in sad && versioned) {
-                if (sad['v'] != dsad["v"]) {
-                    return false
+            if ('v' in sad && versioned) {
+                if (sad['v'] != dsad['v']) {
+                    return false;
                 }
             }
 
             if (prefixed && sad[label] != this.qb64) {
-                return false
+                return false;
             }
-
         } catch (e) {
-            return false
+            return false;
         }
 
-        return true
+        return true;
     }
 
     private static _serialze(sad: Dict<any>, kind?: Serials): string {
-        let knd = Serials.JSON
+        let knd = Serials.JSON;
         if ('v' in sad) {
-            [knd] = deversify(sad['v'])
+            [, knd] = deversify(sad['v']);
         }
 
         if (kind == undefined) {
-            kind = knd
+            kind = knd;
         }
 
-        return dumps(sad, kind)
+        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>] {
+    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.`)
+            throw new Error(`Missing id field labeled=${label} in sad.`);
         }
-        let raw
-        [raw, sad]= Saider._derive(sad, code, kind, label)
-        let saider = new Saider({raw: raw, code: code}, undefined, kind, label)
-        sad[label] = saider.qb64
-        return [saider, 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,36 +1,47 @@
-import {Signer} from "./signer";
+import { Signer } from './signer';
 
 import { Matter, MtrDex } from './matter';
-import { EmptyMaterialError } from './kering'
-import libsodium  from 'libsodium-wrappers-sumo';
+import { EmptyMaterialError } from './kering';
+import libsodium from 'libsodium-wrappers-sumo';
 
-export const enum Tier {
-    low = "low",
-    med = "med",
-    high = "high"
+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
+    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) {
+    constructor({
+        raw,
+        code = MtrDex.Salt_128,
+        tier = Tier.low,
+        qb64,
+        qb64b,
+        qb2,
+    }: SalterArgs) {
         try {
-            super({raw, code, qb64, qb64b, qb2});
+            super({ raw, code, qb64, qb64b, qb2 });
         } catch (e) {
-            if(e instanceof EmptyMaterialError) {
+            if (e instanceof EmptyMaterialError) {
                 if (code == MtrDex.Salt_128) {
-                    let salt = libsodium.randombytes_buf(libsodium.crypto_pwhash_SALTBYTES);
-                    super({raw: salt, code: code})
+                    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")
+                    throw new Error(
+                        'invalid code for Salter, only Salt_128 accepted'
+                    );
                 }
             } else {
                 throw e;
@@ -38,52 +49,72 @@ export class Salter extends Matter {
         }
 
         if (this.code != MtrDex.Salt_128) {
-            throw new Error("invalid code for Salter, only Salt_128 accepted")
+            throw new Error('invalid code for Salter, only Salt_128 accepted');
         }
 
-        this._tier = tier !== null ? tier : Tier.low
+        this._tier = tier !== null ? tier : Tier.low;
     }
 
-    private stretch(size: number = 32, path: string = "", tier: Tier | null = null, temp: boolean = false): Uint8Array {
+    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
+        let opslimit: number, memlimit: number;
 
+        // Harcoded values based on keripy
         if (temp) {
-            opslimit = libsodium.crypto_pwhash_OPSLIMIT_MIN
-            memlimit = libsodium.crypto_pwhash_MEMLIMIT_MIN
-
+            opslimit = 1; //libsodium.crypto_pwhash_OPSLIMIT_MIN
+            memlimit = 8192; //libsodium.crypto_pwhash_MEMLIMIT_MIN
         } else {
             switch (tier) {
                 case Tier.low:
-                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE
-                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE
+                    opslimit = 2; //libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE
+                    memlimit = 67108864; //libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE
                     break;
                 case Tier.med:
-                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_MODERATE
-                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_MODERATE
+                    opslimit = 3; //libsodium.crypto_pwhash_OPSLIMIT_MODERATE
+                    memlimit = 268435456; //libsodium.crypto_pwhash_MEMLIMIT_MODERATE
                     break;
                 case Tier.high:
-                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE
-                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE
+                    opslimit = 4; //libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE
+                    memlimit = 1073741824; //libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE
                     break;
                 default:
-                    throw new Error(`Unsupported security tier = ${tier}.`)
+                    throw new Error(`Unsupported security tier = ${tier}.`);
             }
         }
 
-        return libsodium.crypto_pwhash(size, path, this.raw, opslimit, memlimit, libsodium.crypto_pwhash_ALG_DEFAULT)
+        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 {
-        let seed = this.stretch(Matter._rawSize(code), path, tier, temp)
+    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})
+        return new Signer({
+            raw: seed,
+            code: code,
+            transferable: transferable,
+        });
     }
 
     get tier(): Tier | null {
         return this._tier;
     }
-
-}
+}

package/src/keri/core/seqner.ts

@@ -0,0 +1,46 @@
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { intToBytes, bytesToInt } from './utils';
+/**
+ * @description  Seqner: subclass of Matter, cryptographic material, for ordinal numbers
+ * such as sequence numbers or first seen ordering numbers.
+ * Seqner provides fully qualified format for ordinals (sequence numbers etc)
+ * when provided as attached cryptographic material elements.
+ */
+export class Seqner extends Matter {
+    constructor({
+        raw,
+        code = MtrDex.Salt_128,
+        qb64,
+        qb64b,
+        qb2,
+        sn,
+        snh,
+        ...kwa
+    }: MatterArgs & { sn?: number; snh?: string }) {
+        if (!raw && !qb64b && !qb64 && !qb2) {
+            if (sn === undefined) {
+                if (snh === undefined) {
+                    sn = 0;
+                } else {
+                    sn = parseInt(snh, 16);
+                }
+            }
+
+            raw = intToBytes(sn, Matter._rawSize(MtrDex.Salt_128));
+        }
+
+        super({ raw, code, qb64, qb64b, qb2, ...kwa });
+
+        if (this.code !== MtrDex.Salt_128) {
+            throw new Error(`Invalid code = ${this.code} for Seqner.`);
+        }
+    }
+
+    get sn(): number {
+        return bytesToInt(this.raw); //To check if other readUInt64 is needed
+    }
+
+    get snh(): string {
+        return this.sn.toString(16);
+    }
+}

package/src/keri/core/serder.ts

@@ -1,34 +1,53 @@
-import {MtrDex} from "./matter";
-import {deversify, Dict, Ident, Serials, versify, Version, Versionage} from "./core";
+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 _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
+    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>) {
-        let [raw, ident, kind, kd, version] = this._exhale(ked, this._kind)
-        let size = raw.length
-        this._raw = raw
-        this._ident = ident
-        this._ked = kd
-        this._kind = kind
-        this._size = size
-        this._version = version
+        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
+        return this._ked;
     }
 
     get code(): string {
@@ -39,61 +58,106 @@ export class Serder {
         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
+        return this._kind;
     }
 
-    private _exhale(ked: Dict<any>, kind: Serials): [string, Ident, Serials, Dict<any>, Version] {
-        return sizeify(ked, kind)
+    private _exhale(
+        ked: Dict<any>,
+        kind: Serials
+    ): [string, Ident, Serials, Dict<any>, Version] {
+        return sizeify(ked, kind);
     }
 
     get ident(): Ident {
-        return this._ident
+        return this._ident;
     }
 
     get size(): number {
-        return this._size
+        return this._size;
     }
 
     get version(): Version {
-        return this._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)
+        return JSON.stringify(this._ked, undefined, 2);
     }
 }
 
 export function dumps(ked: Object, kind: Serials.JSON): string {
     if (kind == Serials.JSON) {
-        return JSON.stringify(ked)
+        return JSON.stringify(ked);
     } else {
-        throw new Error("unsupported event encoding")
+        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")
+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');
     }
 
-    let ident = Ident.KERI
-    let [knd, version,] = deversify(ked["v"] as string)
+    const [ident, knd, version] = deversify(ked['v'] as string);
     if (version != Versionage) {
-        throw new Error(`unsupported version ${version.toString()}`)
+        throw new Error(`unsupported version ${version.toString()}`);
     }
 
     if (kind == undefined) {
-        kind = knd
+        kind = knd;
     }
 
-    let raw = dumps(ked, kind)
-    let size = raw.length
-
-    ked['v'] = versify(ident, version, kind, size)
+    let raw = dumps(ked, kind);
+    const size = raw.length;
 
-    raw = dumps(ked, kind)
+    ked['v'] = versify(ident, version, kind, size);
 
-    return [raw, ident, kind, ked, version]
+    raw = dumps(ked, kind);
 
+    return [raw, ident, kind, ked, version];
 }