signify-ts 0.1.0

package/dist/keri/core/siger.d.ts

@@ -0,0 +1,22 @@
+import { Indexer, IndexerArgs } from "./indexer";
+import { Verfer } from "./verfer";
+/**
+   Siger is subclass of Indexer, indexed signature material,
+    Adds .verfer property which is instance of Verfer that provides
+          associated signature verifier.
+
+    See Indexer for inherited attributes and properties:
+
+    Attributes:
+
+    Properties:
+        .verfer is Verfer object instance
+
+    Methods:
+ **/
+export declare class Siger extends Indexer {
+    private _verfer?;
+    constructor({ raw, code, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
+    get verfer(): Verfer | undefined;
+    set verfer(verfer: Verfer | undefined);
+}

package/dist/keri/core/signer.d.ts

@@ -0,0 +1,34 @@
+export {};
+import { Matter } from './matter';
+import { Verfer } from "./verfer";
+import { Cigar } from "./cigar";
+import { Siger } from "./siger";
+/**
+ * @description Signer is Matter subclass with method to create signature of serialization
+ * It will use .raw as signing (private) key seed
+ * .code as cipher suite for signing and new property .verfer whose property
+ *  .raw is public key for signing.
+ *  If not provided .verfer is generated from private key seed using .code
+ as cipher suite for creating key-pair.
+ */
+interface SignerArgs {
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    transferable?: boolean;
+}
+export declare class Signer extends Matter {
+    private readonly _sign;
+    private readonly _verfer;
+    constructor({ raw, code, qb64, qb64b, qb2, transferable }: SignerArgs);
+    /**
+     * @description Property verfer:
+     Returns Verfer instance
+     Assumes ._verfer is correctly assigned
+     */
+    get verfer(): Verfer;
+    sign(ser: Uint8Array, index?: number | null, only?: boolean, ondex?: number | undefined): any;
+    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null, only: boolean | undefined, ondex: number | undefined): Cigar | Siger;
+}

package/dist/keri/core/utils.d.ts

@@ -0,0 +1,16 @@
+export declare function pad(n: any, width?: number, z?: number): string;
+/**
+ * @description  Returns list of depth first recursively extracted values from elements of
+    key event dict ked whose flabels are in lables list
+
+ * @param {*} ked  ked is key event dict
+ * @param {*} labels    labels is list of element labels in ked from which to extract values
+ */
+export declare function extractValues(ked: any, labels: any): any;
+export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
+/**
+ * @description Returns True if obj is non-string iterable, False otherwise
+
+ * @param {*} obj
+ */
+export declare function range(start: any, stop: any, step: any): any[];

package/dist/signify-ts.cjs.development.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sum = function sum(a, b) {
+  {
+    console.log('boop');
+  }
+  return a + b;
+};
+
+exports.sum = sum;
+//# sourceMappingURL=signify-ts.cjs.development.js.map

package/dist/signify-ts.cjs.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signify-ts.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["export const sum = (a: number, b: number) => {\n  if ('development' === process.env.NODE_ENV) {\n    console.log('boop');\n  }\n  return a + b;\n};\n"],"names":["sum","a","b","console","log"],"mappings":";;;;IAAaA,GAAG,GAAG,SAANA,GAAG,CAAIC,CAAS,EAAEC,CAAS;EACM;IAC1CC,OAAO,CAACC,GAAG,CAAC,MAAM,CAAC;;EAErB,OAAOH,CAAC,GAAGC,CAAC;AACd;;;;"}

package/dist/signify-ts.cjs.production.min.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.sum=function(e,t){return e+t};
+//# sourceMappingURL=signify-ts.cjs.production.min.js.map

package/dist/signify-ts.cjs.production.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signify-ts.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["export const sum = (a: number, b: number) => {\n  if ('development' === process.env.NODE_ENV) {\n    console.log('boop');\n  }\n  return a + b;\n};\n"],"names":["a","b"],"mappings":"gFAAmB,SAACA,EAAWC,GAI7B,OAAOD,EAAIC"}

package/dist/signify-ts.esm.js

@@ -0,0 +1,9 @@
+var sum = function sum(a, b) {
+  if ('development' === process.env.NODE_ENV) {
+    console.log('boop');
+  }
+  return a + b;
+};
+
+export { sum };
+//# sourceMappingURL=signify-ts.esm.js.map

package/dist/signify-ts.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signify-ts.esm.js","sources":["../src/index.ts"],"sourcesContent":["export const sum = (a: number, b: number) => {\n  if ('development' === process.env.NODE_ENV) {\n    console.log('boop');\n  }\n  return a + b;\n};\n"],"names":["sum","a","b","process","env","NODE_ENV","console","log"],"mappings":"IAAaA,GAAG,GAAG,SAANA,GAAG,CAAIC,CAAS,EAAEC,CAAS;EACtC,IAAI,aAAa,KAAKC,OAAO,CAACC,GAAG,CAACC,QAAQ,EAAE;IAC1CC,OAAO,CAACC,GAAG,CAAC,MAAM,CAAC;;EAErB,OAAON,CAAC,GAAGC,CAAC;AACd;;;;"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "start": "tsdx watch",
+    "build": "tsdx build",
+    "test": "tsdx test",
+    "lint": "tsdx lint",
+    "prepare": "tsdx build",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "tsdx lint"
+    }
+  },
+  "prettier": {
+    "printWidth": 80,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "name": "signify-ts",
+  "author": "Phil Feairheller",
+  "module": "dist/signify-ts.js",
+  "size-limit": [
+    {
+      "path": "dist/signify-ts.cjs.production.min.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/signify-ts.esm.js",
+      "limit": "10 KB"
+    }
+  ],
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^5.0.4",
+    "@types/lodash": "^4.14.185",
+    "@types/urlsafe-base64": "^1.0.28",
+    "husky": "^7.0.2",
+    "jest": "^29.3.1",
+    "size-limit": "^5.0.4",
+    "ts-migrate": "^0.1.23",
+    "tsdx": "^0.14.1",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.3"
+  },
+  "dependencies": {
+    "@types/libsodium-wrappers-sumo": "^0.7.5",
+    "blake3": "^2.1.7",
+    "cbor": "^8.0.0",
+    "collections": "^5.1.12",
+    "libsodium-wrappers-sumo": "^0.7.9",
+    "lodash": "^4.17.21",
+    "msgpack5": "^5.3.2",
+    "urlsafe-base64": "^1.0.0",
+    "xregexp": "^5.1.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export const sum = (a: number, b: number) => {
+  if ('development' === process.env.NODE_ENV) {
+    console.log('boop');
+  }
+  return a + b;
+};

package/src/keri/core/cigar.ts

@@ -0,0 +1,19 @@
+import {Verfer} from "./verfer";
+import {Matter, MatterArgs} from "./matter";
+
+
+export class Cigar extends Matter {
+    private _verfer: Verfer
+    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs, verfer: Verfer) {
+        super({raw, code, qb64, qb64b, qb2});
+        this._verfer = verfer
+    }
+
+    get verfer(): Verfer {
+        return this._verfer
+    }
+
+    set verfer(verfer:Verfer) {
+        this._verfer = verfer
+    }
+}

package/src/keri/core/cipher.ts

@@ -0,0 +1,25 @@
+import {Matter, MatterArgs, MtrDex} from "./matter";
+import {Decrypter} from "./decrypter";
+
+
+export class Cipher extends Matter {
+    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs) {
+        if (raw != undefined && code == undefined) {
+            if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Salt)) {
+                code = MtrDex.X25519_Cipher_Salt
+            } else if (raw.length  == Matter._rawSize(MtrDex.X25519_Cipher_Seed)) {
+                code = MtrDex.X25519_Cipher_Salt
+            }
+        }
+        super({raw: raw, code: code, qb64b: qb64b, qb64: qb64, qb2: qb2});
+
+        if (!(Array.from([MtrDex.X25519_Cipher_Salt, MtrDex.X25519_Cipher_Seed]).includes(this.code))) {
+            throw new Error(`Unsupported Cipher code == ${this.code}`)
+        }
+    }
+
+    decrypt(prikey: Uint8Array | undefined = undefined, seed: Uint8Array | undefined = undefined) {
+        let decrypter = new Decrypter({qb64b: prikey}, seed)
+        return decrypter.decrypt(this.qb64b)
+    }
+}

package/src/keri/core/core.ts

@@ -0,0 +1,174 @@
+const util = require('./utils');
+import {TextEncoder, TextDecoder} from 'util'
+
+export const VERRAWSIZE = 6;
+export const Versionage = {major: 1, minor: 0};
+export const Serialage = {json: '', mgpk: '', cbor: ''};
+export const Vstrings = Serialage;
+export const Serials = {json: 'JSON', mgpk: 'MGPK', cbor: 'CBOR'};
+
+// # element labels to exclude in digest or signature derivation from inception icp
+export const IcpExcludes = ['pre'];
+// # element labels to exclude in digest or signature derivation from delegated inception dip
+export const DipExcludes = ['pre'];
+export const Ilks = {
+    icp: 'icp',
+    rot: 'rot',
+    ixn: 'ixn',
+    dip: 'dip',
+    drt: 'drt',
+    rct: 'rct',
+    vrc: 'vrc',
+};
+
+export const IcpLabels = ["v", "i", "s", "t", "kt", "k", "n",
+    "bt", "b", "c", "a"];
+
+export const DipLabels = ["v", "i", "s", "t", "kt", "k", "n",
+    "bt", "b", "c", "a", "di"];
+
+export const RotLabels = ["v", "i", "s", "t", "p", "kt", "k", "n",
+    "bt", "br", "ba", "a"]
+export const DrtLabels = ["v", "i", "s", "t", "p", "kt", "k", "n",
+    "bt", "br", "ba", "a"]
+export const IxnLabels = ["v", "i", "s", "t", "p", "a"]
+
+export const KsnLabels = ["v", "i", "s", "t", "p", "d", "f", "dt", "et", "kt", "k", "n",
+    "bt", "b", "c", "ee", "di", "r"]
+
+export const RpyLabels = ["v", "t", "d", "dt", "r", "a"]
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+export const VERFULLSIZE = 17;
+export const MINSNIFFSIZE = 12 + VERFULLSIZE;
+export const MINSIGSIZE = 4;
+
+/**
+ * @description  It will return version string
+ */
+export function versify(version: { major: number, minor: number }, kind = Serials.json, size: number) {
+    if (!(Object.values(Serials).indexOf(kind) > -1)) {
+        throw new Error('Invalid serialization kind =' + kind);
+    }
+
+    if (!version) {
+        version = Versionage;
+    }
+
+    const hex1 = version.major.toString(16);
+    const hex2 = version.minor.toString(16);
+    const kindHex = kind;
+    const hex3 = util.pad(size.toString(16), VERRAWSIZE);
+
+    return `KERI${hex1}${hex2}${kindHex}${hex3}_`;
+}
+
+Vstrings.json = versify(Versionage, Serials.json, 0);
+Vstrings.mgpk = versify(Versionage, Serials.mgpk, 0);
+Vstrings.cbor = versify(Versionage, Serials.cbor, 0);
+
+// const version_pattern = 'KERI(?P<major>[0-9a-f])(?P<minor>[0-9a-f])
+// (?P<kind>[A-Z]{4})(?P<size>[0-9a-f]{6})'
+// const version_pattern1 = `KERI\(\?P<major>\[0\-9a\-f\]\)\(\?P<minor>\[0\-9a\-f\]\)\
+// (\?P<kind>\[A\-Z\]\{4\}\)\(\?P<size>\[0\-9a\-f\]\{6\}\)_`
+
+export const VEREX = 'KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})';
+
+// Regex pattern matching
+
+/**
+ * @description This function is use to deversify the version
+ * Here we will use regex to  to validate and extract serialization kind,size and version
+ * @param {string} vs   version string
+ * @return {Object}  contaning kind of serialization like cbor,json,mgpk
+ *                    version = version of object ,size = raw size integer
+ */
+export function deversify(versionString: string) {
+    let kind;
+    let size;
+    const version = Versionage;
+
+    // we need to identify how to match the buffers pattern ,like we do regex matching for strings
+    const re = new RegExp(VEREX);
+
+    const match = re.exec(versionString);
+
+    if (match) {
+        [version.major, version.minor, kind, size] = [
+            +match[1],
+            +match[2],
+            match[3],
+            match[4],
+        ];
+        if (!Object.values(Serials).includes(kind)) {
+            throw new Error(`Invalid serialization kind = ${kind}`);
+        }
+        return [kind, version, size];
+    }
+    throw new Error(`Invalid version string = ${versionString}`);
+}
+
+export const B64ChrByIdx = new Map<number, string>([[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D'], [4, 'E'], [5, 'F'],
+    [6, 'G'], [7, 'H'], [8, 'I'], [9, 'J'], [10, 'K'], [11, 'L'], [12, 'M'], [13, 'N'], [14, 'O'], [15, 'P'],
+    [16, 'Q'], [17, 'R'], [18, 'S'], [19, 'T'], [20, 'U'], [21, 'V'], [22, 'W'], [23, 'X'], [24, 'Y'], [25, 'Z'],
+    [26, 'a'], [27, 'b'], [28, 'c'], [29, 'd'], [30, 'e'], [31, 'f'], [32, 'g'], [33, 'h'], [34, 'i'], [35, 'j'],
+    [36, 'k'], [37, 'l'], [38, 'm'], [39, 'n'], [40, 'o'], [41, 'p'], [42, 'q'], [43, 'r'], [44, 's'], [45, 't'],
+    [46, 'u'], [47, 'v'], [48, 'w'], [49, 'x'], [50, 'y'], [51, 'z'],[ 52, '0'], [53, '1'], [54, '2'], [55, '3'],
+    [56, '4'], [57, '5'], [58, '6'], [59, '7'], [60, '8'], [61, '9'], [62, '-'], [63, '_']]);
+
+export const B64IdxByChr = new Map<string, number>(Array.from(B64ChrByIdx, entry => [entry[1], entry[0]]))
+
+export function intToB64(i:number | undefined, l=1): string {
+    let out = ""
+    while(l != 0) {
+        out = B64ChrByIdx.get(i! % 64) + out
+        i = Math.floor(i! / 64)
+        if (i == 0) {
+            break
+        }
+    }
+
+    for(let i = 0; i < (l - out.length); i++) {
+        out = "A" + out
+    }
+
+    return out
+}
+
+export function intToB64b(n: number, l: number = 1): Uint8Array {
+    let s = intToB64(n, l)
+    return b(s)
+}
+
+export function b64ToInt(s: string): number {
+    if (s.length == 0) {
+        throw new Error("Empty string, conversion undefined.")
+    }
+
+    let i = 0
+    let rev =  [...s].reverse()
+    rev.forEach((c: string, e: number) => {
+        i |= B64IdxByChr.get(c)! << (e * 6)
+    })
+
+    return i
+}
+
+export function b(s?: string): Uint8Array {
+    return encoder.encode(s)
+}
+
+export function d(u? :Uint8Array): string {
+    return decoder.decode(u)
+}
+
+
+export function readInt(array: Uint8Array) {
+    let value = 0;
+    for (let i = 0; i < array.length; i++) {
+        value = (value * 256) + array[i];
+    }
+    return value;
+}

package/src/keri/core/decrypter.ts

@@ -0,0 +1,66 @@
+import libsodium from "libsodium-wrappers-sumo";
+
+import {Matter, MatterArgs, MtrDex} from './matter';
+import {Signer} from "./signer";
+import {Cipher} from "./cipher";
+import {EmptyMaterialError} from "./kering";
+import {Salter} from "./salter";
+
+
+export class Decrypter extends Matter {
+    private readonly _decrypt: any;
+    constructor({raw, code = MtrDex.X25519_Private, qb64, qb64b, qb2}:MatterArgs, seed: Uint8Array | undefined = undefined) {
+        try {
+            super({raw, code, qb64, qb64b, qb2})
+        } catch(e) {
+            if(e instanceof EmptyMaterialError) {
+                if (seed != undefined) {
+                    let signer = new Signer({qb64b: seed})
+                    if (signer.code != MtrDex.Ed25519_Seed) {
+                        throw new Error(`Unsupported signing seed derivation code ${signer.code}`)
+                    }
+                    let sigkey = new Uint8Array(signer.raw.length + signer.verfer.raw.length)
+                    sigkey.set(signer.raw)
+                    sigkey.set(signer.verfer.raw, signer.raw.length)
+                    raw = libsodium.crypto_sign_ed25519_sk_to_curve25519(sigkey)
+                    super({raw, code, qb64, qb64b, qb2})
+                }
+                else {
+                    throw e
+                }
+            } else {
+                throw e
+            }
+        }
+
+        if (this.code == MtrDex.X25519_Private) {
+            this._decrypt = this._x25519
+        } else {
+            throw new Error(`Unsupported decrypter code = ${this.code}.`)
+        }
+    }
+
+    decrypt(ser: Uint8Array | null = null, cipher: Cipher | null = null, transferable: boolean = false) {
+        if (ser == null && cipher == null) {
+            throw new EmptyMaterialError("Neither ser or cipher were provided")
+        }
+
+        if (ser != null) {
+            cipher = new Cipher({qb64b: ser})
+        }
+
+        return this._decrypt(cipher, this.raw, transferable)
+    }
+
+    _x25519(cipher: Cipher, prikey: Uint8Array, transferable: boolean = false) {
+        let pubkey = libsodium.crypto_scalarmult_base(prikey)
+        let plain = libsodium.crypto_box_seal_open(cipher.raw, pubkey, prikey)
+        if (cipher.code == MtrDex.X25519_Cipher_Salt) {
+            return new Salter({qb64b: plain})
+        } else if (cipher.code == MtrDex.X25519_Cipher_Seed) {
+            return new Signer({qb64b: plain, transferable: transferable})
+        } else {
+            throw new Error(`Unsupported cipher text code == ${cipher.code}`)
+        }
+    }
+}

package/src/keri/core/diger.ts

@@ -0,0 +1,82 @@
+const blake3 = require('blake3');
+import {Matter, MatterArgs, MtrDex} from './matter';
+
+/**
+ * @description : Diger is subset of Matter and is used to verify the digest of serialization
+ * It uses  .raw : as digest
+ * .code as digest algorithm
+ *
+ */
+
+
+export class Diger extends Matter {
+    private readonly _verify: any
+
+    // This constructor will assign digest verification function to ._verify
+    constructor({raw, code = MtrDex.Blake3_256, qb64, qb64b, qb2}: MatterArgs, ser: Uint8Array | null = null) {
+        try {
+            super({raw, code, qb64, qb64b, qb2});
+        } catch (error: any) {
+            if (ser == null) {
+                throw error;
+            }
+
+            if (code === MtrDex.Blake3_256) {
+                const hasher = blake3.createHash();
+                const dig = hasher.update(ser).digest('');
+                super({raw: dig, code: code});
+            } else {
+                throw new Error(`Unsupported code = ${code} for digester.`);
+            }
+        }
+
+        if (code === MtrDex.Blake3_256) {
+            this._verify = this.blake3_256;
+        } else {
+            throw new Error(`Unsupported code = ${code} for digester.`);
+        }
+    }
+
+
+    /**
+     *
+     * @param {Uint8Array} ser  serialization bytes
+     * @description  This method will return true if digest of bytes serialization ser matches .raw
+     * using .raw as reference digest for ._verify digest algorithm determined
+     by .code
+     */
+    verify(ser: Uint8Array): boolean {
+        return this._verify(ser, this.raw);
+    }
+
+    compare(ser: Uint8Array, dig: any = null, diger: Diger | null = null ) {
+        if (dig != null) {
+            if (dig.toString() == this.qb64) {
+                return true
+            }
+
+            diger = new Diger({qb64b: dig})
+        } else if (diger != null) {
+            if (diger.qb64b == this.qb64b) {
+                return true;
+            }
+        }
+
+        else {
+            throw new Error("Both dig and diger may not be None.")
+        }
+
+        if (diger.code == this.code) {
+            return false
+        }
+
+        return diger.verify(ser) && this.verify(ser)
+    }
+
+
+    blake3_256(ser: Uint8Array, dig: any) {
+        const hasher = blake3.createHash();
+        let digest = hasher.update(ser).digest('');
+        return (digest.toString() === dig.toString());
+    }
+}

package/src/keri/core/encrypter.ts

@@ -0,0 +1,60 @@
+import libsodium from "libsodium-wrappers-sumo";
+
+import {Matter, MatterArgs, MtrDex} from './matter';
+import {Verfer} from "./verfer";
+import {Signer} from "./signer";
+import {Cipher} from "./cipher";
+import {arrayEquals} from "./utils";
+
+
+export class Encrypter extends Matter {
+    private _encrypt: any;
+    constructor({raw, code = MtrDex.X25519, qb64, qb64b, qb2}:MatterArgs, verkey: Uint8Array | null = null) {
+        if (raw == undefined && verkey != null) {
+            let verfer = new Verfer({qb64b: verkey})
+            if (!Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(verfer.code)) {
+                throw new Error(`Unsupported verkey derivation code = ${verfer.code}.`)
+            }
+            raw = libsodium.crypto_sign_ed25519_pk_to_curve25519(verfer.raw)
+        }
+
+        super({raw, code, qb64, qb64b, qb2});
+
+        if (this.code == MtrDex.X25519) {
+            this._encrypt = this._x25519;
+        } else {
+            throw new Error(`Unsupported encrypter code = ${this.code}.`)
+        }
+    }
+
+    verifySeed(seed: Uint8Array) {
+        let signer = new Signer({qb64b: seed})
+        let keypair = libsodium.crypto_sign_seed_keypair(signer.raw);
+        let pubkey = libsodium.crypto_sign_ed25519_pk_to_curve25519(keypair.publicKey)
+        return arrayEquals(pubkey, this.raw)
+    }
+
+    encrypt(ser: Uint8Array | null = null, matter: Matter | null = null) {
+        if (ser == null && matter == null) {
+            throw new Error("Neither ser nor matter are provided.")
+        }
+
+        if (ser != null) {
+            matter = new Matter({qb64b: ser})
+        }
+
+        let code
+        if (matter!.code == MtrDex.Salt_128) {
+            code = MtrDex.X25519_Cipher_Salt
+        } else {
+            code = MtrDex.X25519_Cipher_Seed
+        }
+
+        return this._encrypt(matter!.qb64, this.raw, code)
+    }
+
+    _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string) {
+        let raw = libsodium.crypto_box_seal(ser, pubkey)
+        return new Cipher({raw: raw, code: code})
+    }
+}