signify-ts 0.1.0 → 0.2.0

package/src/keri/core/salter.ts

@@ -1,36 +1,47 @@
-import {Signer} from "./signer";
+import { Signer } from './signer';
 
-export {};
-const { Matter, MtrDex } = require('./matter');
-const { EmptyMaterialError } = require('./kering')
-import libsodium  from 'libsodium-wrappers-sumo';
+import { Matter, MtrDex } from './matter';
+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?:string
-    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,48 +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

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

package/src/keri/core/siger.ts

@@ -1,5 +1,5 @@
-import {IdxSigDex, Indexer, IndexerArgs} from "./indexer";
-import {Verfer} from "./verfer";
+import { IdxSigDex, Indexer, IndexerArgs } from './indexer';
+import { Verfer } from './verfer';
 
 /**
    Siger is subclass of Indexer, indexed signature material,
@@ -17,23 +17,24 @@ import {Verfer} from "./verfer";
  **/
 
 export class Siger extends Indexer {
-
-  private _verfer?: Verfer
-  constructor({raw, code, qb64, qb64b, qb2}: IndexerArgs, verfer?: Verfer) {
-    super({raw, code, qb64, qb64b, qb2});
-
-    if (!IdxSigDex.has(this.code)) {
-      throw new Error(`Invalid code = ${this.code} for Siger.`)
+    private _verfer?: Verfer;
+    constructor(
+        { raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs,
+        verfer?: Verfer
+    ) {
+        super({ raw, code, index, ondex, qb64, qb64b, qb2 });
+
+        if (!IdxSigDex.has(this.code)) {
+            throw new Error(`Invalid code = ${this.code} for Siger.`);
+        }
+        this._verfer = verfer;
     }
-    this._verfer = verfer
-  }
-
-  get verfer(): Verfer | undefined {
-    return this._verfer;
-  }
 
-  set verfer(verfer: Verfer | undefined) {
-    this._verfer = verfer;
-  }
+    get verfer(): Verfer | undefined {
+        return this._verfer;
+    }
 
+    set verfer(verfer: Verfer | undefined) {
+        this._verfer = verfer;
+    }
 }

package/src/keri/core/signer.ts

@@ -1,14 +1,14 @@
-import {EmptyMaterialError} from "./kering";
+import { EmptyMaterialError } from './kering';
 
 export {};
 import libsodium from 'libsodium-wrappers-sumo';
-import {Matter} from './matter';
-import {MtrDex} from './matter';
-import {Verfer} from "./verfer";
-import {Cigar} from "./cigar";
-import {Siger} from "./siger";
-import {IdrDex} from "./indexer";
-
+import { Matter } from './matter';
+import { MtrDex } from './matter';
+import { Verfer } from './verfer';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+import { IdrDex } from './indexer';
+import { Buffer } from 'buffer';
 
 /**
  * @description Signer is Matter subclass with method to create signature of serialization
@@ -19,48 +19,57 @@ import {IdrDex} from "./indexer";
  as cipher suite for creating key-pair.
  */
 interface SignerArgs {
-    raw?: Uint8Array | undefined
-    code?: string
-    qb64b?: Uint8Array | undefined
-    qb64?: string
-    qb2?: Uint8Array | undefined
-    transferable?: boolean
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    transferable?: boolean;
 }
 
 export class Signer extends Matter {
-    private readonly _sign
-    private readonly _verfer: Verfer
-
-    constructor({raw, code = MtrDex.Ed25519_Seed, qb64, qb64b, qb2, transferable = true}: SignerArgs) {
+    private readonly _sign: Function;
+    private readonly _verfer: Verfer;
+
+    constructor({
+        raw,
+        code = MtrDex.Ed25519_Seed,
+        qb64,
+        qb64b,
+        qb2,
+        transferable = true,
+    }: SignerArgs) {
         try {
-            super({raw, code, qb64, qb64b, qb2})
+            super({ raw, code, qb64, qb64b, qb2 });
         } catch (e) {
             if (e instanceof EmptyMaterialError) {
                 if (code == MtrDex.Ed25519_Seed) {
-                    let raw = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
-                    super({raw, code, qb64, qb64b, qb2})
+                    const raw = libsodium.randombytes_buf(
+                        libsodium.crypto_sign_SEEDBYTES
+                    );
+                    super({ raw, code, qb64, qb64b, qb2 });
                 } else {
-                    throw new Error(`Unsupported signer code = ${code}.`)
+                    throw new Error(`Unsupported signer code = ${code}.`);
                 }
             } else {
-                throw e
+                throw e;
             }
         }
-        let verfer
+        let verfer;
         if (this.code == MtrDex.Ed25519_Seed) {
-            this._sign = this._ed25519
-            const keypair = libsodium.crypto_sign_seed_keypair(this.raw)
-            verfer = new Verfer({raw: keypair.publicKey, code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N})
-
+            this._sign = this._ed25519;
+            const keypair = libsodium.crypto_sign_seed_keypair(this.raw);
+            verfer = new Verfer({
+                raw: keypair.publicKey,
+                code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N,
+            });
         } else {
-            throw new Error(`Unsupported signer code = ${this.code}.`)
+            throw new Error(`Unsupported signer code = ${this.code}.`);
         }
 
-        this._verfer = verfer
-
+        this._verfer = verfer;
     }
 
-
     /**
      * @description Property verfer:
      Returns Verfer instance
@@ -70,43 +79,55 @@ export class Signer extends Matter {
         return this._verfer;
     }
 
-    sign(ser: Uint8Array, index: number | null = null, only: boolean = false, ondex: number | undefined = undefined) {
-        return this._sign(ser, this.raw, this.verfer, index, only, ondex)
+    sign(
+        ser: Uint8Array,
+        index: number | null = null,
+        only: boolean = false,
+        ondex: number | undefined = undefined
+    ): Siger | Cigar {
+        return this._sign(ser, this.raw, this.verfer, index, only, ondex);
     }
 
-    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null,
-             only: boolean = false, ondex: number | undefined) {
-
-        let sig = libsodium.crypto_sign_detached(
+    _ed25519(
+        ser: Uint8Array,
+        seed: Uint8Array,
+        verfer: Verfer,
+        index: number | null,
+        only: boolean = false,
+        ondex: number | undefined
+    ) {
+        const sig = libsodium.crypto_sign_detached(
             ser,
-            Buffer.concat([seed, verfer.raw]),
+            Buffer.concat([seed, verfer.raw])
         );
 
         if (index == null) {
-            return new Cigar({raw: sig, code: MtrDex.Ed25519_Sig}, verfer);
+            return new Cigar({ raw: sig, code: MtrDex.Ed25519_Sig }, verfer);
         } else {
             let code;
             if (only) {
-                ondex = undefined
+                ondex = undefined;
                 if (index <= 63) {
-                    code = IdrDex.Ed25519_Crt_Sig
+                    code = IdrDex.Ed25519_Crt_Sig;
                 } else {
-                    code = IdrDex.Ed25519_Big_Crt_Sig
+                    code = IdrDex.Ed25519_Big_Crt_Sig;
                 }
             } else {
-                if(ondex == undefined) {
-                    ondex = index
+                if (ondex == undefined) {
+                    ondex = index;
                 }
 
-                if (ondex == index && index <= 63) // both same and small
-                    code = IdrDex.Ed25519_Sig  //  use  small both same
-                else  //  otherwise big or both not same so use big both
-                    code = IdrDex.Ed25519_Big_Sig   // use use big both
-
+                if (ondex == index && index <= 63)
+                    // both same and small
+                    code = IdrDex.Ed25519_Sig; //  use  small both same
+                //  otherwise big or both not same so use big both
+                else code = IdrDex.Ed25519_Big_Sig; // use use big both
             }
 
-            return new Siger({raw: sig, code: code, index: index, ondex: ondex}, verfer)
+            return new Siger(
+                { raw: sig, code: code, index: index, ondex: ondex },
+                verfer
+            );
         }
-
     }
-}
+}