signify-ts 0.1.0 → 0.2.0

package/src/keri/core/bexter.ts

@@ -0,0 +1,138 @@
+import { BexDex, Matter, MatterArgs, MtrDex } from './matter';
+import { EmptyMaterialError } from './kering';
+import Base64 from 'urlsafe-base64';
+
+const B64REX = '^[A-Za-z0-9\\-_]*$';
+export const Reb64 = new RegExp(B64REX);
+
+/*
+
+    Bexter is subclass of Matter, cryptographic material, for variable length
+    strings that only contain Base64 URL safe characters, i.e. Base64 text (bext).
+    When created using the 'bext' paramaeter, the encoded matter in qb64 format
+    in the text domain is more compact than would be the case if the string were
+    passed in as raw bytes. The text is used as is to form the value part of the
+    qb64 version not including the leader.
+
+    Due to ambiguity that arises from pre-padding bext whose length is a multiple of
+    three with one or more 'A' chars. Any bext that starts with an 'A' and whose length
+    is either a multiple of 3 or 4 may not round trip. Bext with a leading 'A'
+    whose length is a multiple of four may have the leading 'A' stripped when
+    round tripping.
+
+        Bexter(bext='ABBB').bext == 'BBB'
+        Bexter(bext='BBB').bext == 'BBB'
+        Bexter(bext='ABBB').qb64 == '4AABABBB' == Bexter(bext='BBB').qb64
+
+    To avoid this problem, only use for applications of base 64 strings that
+    never start with 'A'
+
+    Examples: base64 text strings:
+
+    bext = ""
+    qb64 = '4AAA'
+
+    bext = "-"
+    qb64 = '6AABAAA-'
+
+    bext = "-A"
+    qb64 = '5AABAA-A'
+
+    bext = "-A-"
+    qb64 = '4AABA-A-'
+
+    bext = "-A-B"
+    qb64 = '4AAB-A-B'
+
+
+    Example uses:
+        CESR encoded paths for nested SADs and SAIDs
+        CESR encoded fractionally weighted threshold expressions
+
+
+    Attributes:
+
+    Inherited Properties:  (See Matter)
+        .pad  is int number of pad chars given raw
+
+        .code is  str derivation code to indicate cypher suite
+        .raw is bytes crypto material only without code
+        .index is int count of attached crypto material by context (receipts)
+        .qb64 is str in Base64 fully qualified with derivation code + crypto mat
+        .qb64b is bytes in Base64 fully qualified with derivation code + crypto mat
+        .qb2  is bytes in binary with derivation code + crypto material
+        .transferable is Boolean, True when transferable derivation code False otherwise
+
+    Properties:
+        .text is the Base64 text value, .qb64 with text code and leader removed.
+
+    Hidden:
+        ._pad is method to compute  .pad property
+        ._code is str value for .code property
+        ._raw is bytes value for .raw property
+        ._index is int value for .index property
+        ._infil is method to compute fully qualified Base64 from .raw and .code
+        ._exfil is method to extract .code and .raw from fully qualified Base64
+
+    Methods:
+
+
+
+
+ */
+
+export class Bexter extends Matter {
+    constructor(
+        { raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }: MatterArgs,
+        bext?: string
+    ) {
+        if (
+            raw === undefined &&
+            qb64b === undefined &&
+            qb64 === undefined &&
+            qb2 === undefined
+        ) {
+            if (bext === undefined)
+                throw new EmptyMaterialError('Missing bext string.');
+
+            const match = Reb64.exec(bext);
+            if (!match) throw new Error('Invalid Base64.');
+
+            raw = Bexter._rawify(bext);
+        }
+
+        super({ raw, code, qb64b, qb64, qb2 });
+
+        if (!BexDex.has(this.code))
+            throw new Error(`Invalid code = ${this.code} for Bexter.`);
+    }
+
+    static _rawify(bext: string): Uint8Array {
+        const ts = bext.length % 4; // bext size mod 4
+        const ws = (4 - ts) % 4; // pre conv wad size in chars
+        const ls = (3 - ts) % 3; // post conv lead size in bytes
+        const wad = new Array(ws);
+        wad.fill('A');
+        const base = wad.join('') + bext; // pre pad with wad of zeros in Base64 == 'A'
+        const raw = Base64.decode(base); // [ls:]  // convert and remove leader
+
+        return Uint8Array.from(raw).subarray(ls); // raw binary equivalent of text
+    }
+
+    get bext(): string {
+        const sizage = Matter.Sizes.get(this.code);
+        const wad = Uint8Array.from(new Array(sizage?.ls).fill(0));
+        const bext = Base64.encode(Buffer.from([...wad, ...this.raw]));
+
+        let ws = 0;
+        if (sizage?.ls === 0 && bext !== undefined) {
+            if (bext[0] === 'A') {
+                ws = 1;
+            }
+        } else {
+            ws = (sizage?.ls! + 1) % 4;
+        }
+
+        return bext.substring(ws);
+    }
+}

package/src/keri/core/cigar.ts

@@ -1,19 +1,18 @@
-import {Verfer} from "./verfer";
-import {Matter, MatterArgs} from "./matter";
-
+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
+    private _verfer: Verfer | undefined;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer) {
+        super({ raw, code, qb64, qb64b, qb2 });
+        this._verfer = verfer;
     }
 
-    get verfer(): Verfer {
-        return this._verfer
+    get verfer(): Verfer | undefined {
+        return this._verfer;
     }
 
-    set verfer(verfer:Verfer) {
-        this._verfer = verfer
+    set verfer(verfer: Verfer | undefined) {
+        this._verfer = verfer;
     }
-}
+}

package/src/keri/core/cipher.ts

@@ -1,25 +1,34 @@
-import {Matter, MatterArgs, MtrDex} from "./matter";
-import {Decrypter} from "./decrypter";
-
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { Decrypter } from './decrypter';
 
 export class Cipher extends Matter {
-    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs) {
+    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
+                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});
+        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}`)
+        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)
+    decrypt(
+        prikey: Uint8Array | undefined = undefined,
+        seed: Uint8Array | undefined = undefined
+    ) {
+        const decrypter = new Decrypter({ qb64b: prikey }, seed);
+        return decrypter.decrypt(this.qb64b);
     }
-}
+}

package/src/keri/core/core.ts

@@ -1,16 +1,24 @@
-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 enum Serials {
+    JSON = 'JSON',
+}
+
+export enum Ident {
+    KERI = 'KERI',
+    ACDC = 'ACDC',
+}
+
+export class Version {
+    public major: number;
+    public minor: number;
+
+    constructor(major: number = 1, minor: number = 0) {
+        this.major = major;
+        this.minor = minor;
+    }
+}
+
+export const Versionage = new Version();
+
 export const Ilks = {
     icp: 'icp',
     rot: 'rot',
@@ -19,75 +27,128 @@ export const Ilks = {
     drt: 'drt',
     rct: 'rct',
     vrc: 'vrc',
+    rpy: 'rpy',
+    exn: 'exn',
+    vcp: 'vcp',
+    iss: 'iss',
+    rev: 'rev',
 };
 
-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 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})';
+export const VEREX = '(KERI|ACDC)([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_';
+
+export interface Dict<TValue> {
+    [id: string]: TValue;
+}
 
 // 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
+ * @param {string} versionString   version string
+ * @return {Object}  contaning prototol (KERI or ACDC), kind of serialization like cbor,json,mgpk
  *                    version = version of object ,size = raw size integer
  */
-export function deversify(versionString: string) {
+export function deversify(
+    versionString: string
+): [Ident, Serials, Version, string] {
     let kind;
     let size;
+    let proto;
     const version = Versionage;
 
     // we need to identify how to match the buffers pattern ,like we do regex matching for strings
@@ -96,79 +157,170 @@ export function deversify(versionString: string) {
     const match = re.exec(versionString);
 
     if (match) {
-        [version.major, version.minor, kind, size] = [
-            +match[1],
+        [proto, version.major, version.minor, kind, size] = [
+            match[1],
             +match[2],
-            match[3],
+            +match[3],
             match[4],
+            match[5],
         ];
-        if (!Object.values(Serials).includes(kind)) {
+        if (!Object.values(Serials).includes(kind as Serials)) {
             throw new Error(`Invalid serialization kind = ${kind}`);
         }
-        return [kind, version, size];
+        if (!Object.values(Ident).includes(proto as Ident)) {
+            throw new Error(`Invalid serialization kind = ${kind}`);
+        }
+
+        const ta = kind as keyof typeof Serials;
+        kind = Serials[ta];
+        const pa = proto as keyof typeof Ident;
+        proto = Ident[pa];
+
+        return [proto, 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)
+export function versify(
+    ident: Ident = Ident.KERI,
+    version?: Version,
+    kind: Serials = Serials.JSON,
+    size: number = 0
+) {
+    version = version == undefined ? Versionage : version;
+
+    return `${ident}${version.major.toString(
+        16
+    )}${version.minor.toString()}${kind}${size.toString(16).padStart(6, '0')}_`;
+}
+
+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, l = 1): string {
+    let out = '';
+    while (l != 0) {
+        out = B64ChrByIdx.get(i % 64) + out;
+        i = Math.floor(i / 64);
         if (i == 0) {
-            break
+            break;
         }
     }
 
-    for(let i = 0; i < (l - out.length); i++) {
-        out = "A" + out
+    const x = l - out.length;
+    for (let i = 0; i < x; i++) {
+        out = 'A' + out;
     }
 
-    return out
+    return out;
 }
 
 export function intToB64b(n: number, l: number = 1): Uint8Array {
-    let s = intToB64(n, l)
-    return b(s)
+    const s = intToB64(n, l);
+    return b(s);
 }
 
 export function b64ToInt(s: string): number {
     if (s.length == 0) {
-        throw new Error("Empty string, conversion undefined.")
+        throw new Error('Empty string, conversion undefined.');
     }
 
-    let i = 0
-    let rev =  [...s].reverse()
+    let i = 0;
+    const rev = s.split('').reverse();
     rev.forEach((c: string, e: number) => {
-        i |= B64IdxByChr.get(c)! << (e * 6)
-    })
+        i |= B64IdxByChr.get(c)! << (e * 6);
+    });
 
-    return i
+    return i;
 }
 
 export function b(s?: string): Uint8Array {
-    return encoder.encode(s)
+    return encoder.encode(s);
 }
 
-export function d(u? :Uint8Array): string {
-    return decoder.decode(u)
+export function d(u?: Uint8Array): string {
+    return decoder.decode(u);
 }
 
+export function concat(one: Uint8Array, two: Uint8Array): Uint8Array {
+    const out = new Uint8Array(one.length + two.length);
+    out.set(one);
+    out.set(two, one.length);
+    return out;
+}
 
 export function readInt(array: Uint8Array) {
     let value = 0;
     for (let i = 0; i < array.length; i++) {
-        value = (value * 256) + array[i];
+        value = value * 256 + array[i];
     }
     return value;
-}
+}