signify-ts 0.2.1 → 0.3.0-dev.e31e78d

package/src/keri/core/core.ts

@@ -1,326 +0,0 @@
-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',
-    ixn: 'ixn',
-    dip: 'dip',
-    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 VERFULLSIZE = 17;
-export const MINSNIFFSIZE = 12 + VERFULLSIZE;
-export const MINSIGSIZE = 4;
-
-// 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|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} 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
-): [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
-    const re = new RegExp(VEREX);
-
-    const match = re.exec(versionString);
-
-    if (match) {
-        [proto, version.major, version.minor, kind, size] = [
-            match[1],
-            +match[2],
-            +match[3],
-            match[4],
-            match[5],
-        ];
-        if (!Object.values(Serials).includes(kind as Serials)) {
-            throw new Error(`Invalid serialization kind = ${kind}`);
-        }
-        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 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;
-        }
-    }
-
-    const x = l - out.length;
-    for (let i = 0; i < x; i++) {
-        out = 'A' + out;
-    }
-
-    return out;
-}
-
-export function intToB64b(n: number, l: number = 1): Uint8Array {
-    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.');
-    }
-
-    let i = 0;
-    const rev = s.split('').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 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];
-    }
-    return value;
-}

package/src/keri/core/counter.ts

@@ -1,273 +0,0 @@
-import { Codex, Sizage } from './matter';
-import { b, b64ToInt, d, intToB64 } from './core';
-
-export interface CounterArgs {
-    code?: string;
-    count?: number;
-    countB64?: string;
-    qb64b?: Uint8Array;
-    qb64?: string;
-    qb2?: Uint8Array;
-    strip?: boolean;
-}
-
-export class CounterCodex extends Codex {
-    public ControllerIdxSigs: string = '-A'; // Qualified Base64 Indexed Signature.
-    public WitnessIdxSigs: string = '-B'; // Qualified Base64 Indexed Signature.
-    public NonTransReceiptCouples: string = '-C'; // Composed Base64 Couple, pre+cig.
-    public TransReceiptQuadruples: string = '-D'; // Composed Base64 Quadruple, pre+snu+dig+sig.
-    public FirstSeenReplayCouples: string = '-E'; // Composed Base64 Couple, fnu+dts.
-    public TransIdxSigGroups: string = '-F'; // Composed Base64 Group, pre+snu+dig+ControllerIdxSigs group.
-    public SealSourceCouples: string = '-G'; // Composed Base64 couple, snu+dig of given delegators or issuers event
-    public TransLastIdxSigGroups: string = '-H'; // Composed Base64 Group, pre+ControllerIdxSigs group.
-    public SealSourceTriples: string = '-I'; // Composed Base64 triple, pre+snu+dig of anchoring source event
-    public SadPathSig: string = '-J'; // Composed Base64 Group path+TransIdxSigGroup of SAID of content
-    public SadPathSigGroup: string = '-K'; // Composed Base64 Group, root(path)+SaidPathCouples
-    public PathedMaterialQuadlets: string = '-L'; // Composed Grouped Pathed Material Quadlet (4 char each)
-    public AttachedMaterialQuadlets: string = '-V'; // Composed Grouped Attached Material Quadlet (4 char each)
-    public BigAttachedMaterialQuadlets: string = '-0V'; // Composed Grouped Attached Material Quadlet (4 char each)
-    public KERIProtocolStack: string = '--AAA'; // KERI ACDC Protocol Stack CESR Version
-}
-
-export const CtrDex = new CounterCodex();
-
-export class Counter {
-    static Sizes = new Map(
-        Object.entries({
-            '-A': new Sizage(2, 2, 4, 0),
-            '-B': new Sizage(2, 2, 4, 0),
-            '-C': new Sizage(2, 2, 4, 0),
-            '-D': new Sizage(2, 2, 4, 0),
-            '-E': new Sizage(2, 2, 4, 0),
-            '-F': new Sizage(2, 2, 4, 0),
-            '-G': new Sizage(2, 2, 4, 0),
-            '-H': new Sizage(2, 2, 4, 0),
-            '-I': new Sizage(2, 2, 4, 0),
-            '-J': new Sizage(2, 2, 4, 0),
-            '-K': new Sizage(2, 2, 4, 0),
-            '-L': new Sizage(2, 2, 4, 0),
-            '-V': new Sizage(2, 2, 4, 0),
-            '-0V': new Sizage(3, 5, 8, 0),
-            '--AAA': new Sizage(5, 3, 8, 0),
-        })
-    );
-
-    static Hards = new Map<string, number>([
-        ['-A', 2],
-        ['-B', 2],
-        ['-C', 2],
-        ['-D', 2],
-        ['-E', 2],
-        ['-F', 2],
-        ['-G', 2],
-        ['-H', 2],
-        ['-I', 2],
-        ['-J', 2],
-        ['-K', 2],
-        ['-L', 2],
-        ['-M', 2],
-        ['-N', 2],
-        ['-O', 2],
-        ['-P', 2],
-        ['-Q', 2],
-        ['-R', 2],
-        ['-S', 2],
-        ['-T', 2],
-        ['-U', 2],
-        ['-V', 2],
-        ['-W', 2],
-        ['-X', 2],
-        ['-Y', 2],
-        ['-Z', 2],
-        ['-a', 2],
-        ['-b', 2],
-        ['-c', 2],
-        ['-d', 2],
-        ['-e', 2],
-        ['-f', 2],
-        ['-g', 2],
-        ['-h', 2],
-        ['-i', 2],
-        ['-j', 2],
-        ['-k', 2],
-        ['-l', 2],
-        ['-m', 2],
-        ['-n', 2],
-        ['-o', 2],
-        ['-p', 2],
-        ['-q', 2],
-        ['-r', 2],
-        ['-s', 2],
-        ['-t', 2],
-        ['-u', 2],
-        ['-v', 2],
-        ['-w', 2],
-        ['-x', 2],
-        ['-y', 2],
-        ['-z', 2],
-        ['-0', 3],
-        ['--', 5],
-    ]);
-
-    private _code: string = '';
-    private _count: number = -1;
-
-    constructor({ code, count, countB64, qb64b, qb64, qb2 }: CounterArgs) {
-        if (code != undefined) {
-            if (!Counter.Sizes.has(code)) {
-                throw new Error(`"Unsupported code=${code}.`);
-            }
-
-            const sizage = Counter.Sizes.get(code)!;
-            const cs = sizage.hs + sizage.ss;
-            if (sizage.fs != cs || cs % 4 != 0) {
-                throw new Error(
-                    `Whole code size not full size or not multiple of 4. cs=${cs} fs=${sizage.fs}.`
-                );
-            }
-
-            if (count == undefined) {
-                count = countB64 == undefined ? 1 : b64ToInt(countB64);
-            }
-
-            if (count < 0 || count > 64 ** sizage.ss - 1) {
-                throw new Error(`Invalid count=${count} for code=${code}.`);
-            }
-
-            this._code = code;
-            this._count = count;
-        } else if (qb64b != undefined) {
-            const qb64 = d(qb64b);
-            this._exfil(qb64);
-        } else if (qb64 != undefined) {
-            this._exfil(qb64);
-        } else if (qb2 != undefined) {
-        } else {
-            throw new Error(
-                `Improper initialization need either (code and count) or qb64b or qb64 or qb2.`
-            );
-        }
-    }
-
-    get code(): string {
-        return this._code;
-    }
-
-    get count() {
-        return this._count;
-    }
-
-    get qb64() {
-        return this._infil();
-    }
-
-    get qb64b() {
-        return b(this.qb64);
-    }
-
-    countToB64(l?: number): string {
-        if (l == undefined) {
-            const sizage = Counter.Sizes.get(this.code)!;
-            l = sizage.ss;
-        }
-        return intToB64(this.count, l);
-    }
-
-    static semVerToB64(
-        version: string = '',
-        major: number = 0,
-        minor: number = 0,
-        patch: number = 0
-    ): string {
-        let parts = [major, minor, patch];
-        if (version != '') {
-            const ssplits = version.split('.');
-            const splits = ssplits.map((x) => {
-                if (x == '') return 0;
-                return parseInt(x);
-            });
-
-            const off = splits.length;
-            const x = 3 - off;
-            for (let i = 0; i < x; i++) {
-                splits.push(parts[i + off]);
-            }
-            parts = splits;
-        }
-
-        parts.forEach((p) => {
-            if (p < 0 || p > 63) {
-                throw new Error(
-                    `Out of bounds semantic version. Part=${p} is < 0 or > 63.`
-                );
-            }
-        });
-
-        return parts
-            .map((p) => {
-                return intToB64(p, 1);
-            })
-            .join('');
-    }
-
-    private _infil(): string {
-        const code = this.code;
-        const count = this.count;
-
-        const sizage = Counter.Sizes.get(code)!;
-        const cs = sizage.hs + sizage.ss;
-        if (sizage.fs != cs || cs % 4 != 0) {
-            throw new Error(
-                `Whole code size not full size or not multiple of 4. cs=${cs} fs=${sizage.fs}.`
-            );
-        }
-
-        if (count < 0 || count > 64 ** sizage.ss - 1) {
-            throw new Error(`Invalid count=${count} for code=${code}.`);
-        }
-
-        const both = `${code}${intToB64(count, sizage.ss)}`;
-
-        if (both.length % 4) {
-            throw new Error(
-                `Invalid size = ${both.length} of ${both} not a multiple of 4.`
-            );
-        }
-
-        return both;
-    }
-
-    private _exfil(qb64: string) {
-        if (qb64.length == 0) {
-            throw new Error('Empty Material');
-        }
-
-        const first = qb64.slice(0, 2);
-        if (!Counter.Hards.has(first)) {
-            throw new Error(`Unexpected code ${first}`);
-        }
-
-        const hs = Counter.Hards.get(first)!;
-        if (qb64.length < hs) {
-            throw new Error(`Need ${hs - qb64.length} more characters.`);
-        }
-
-        const hard = qb64.slice(0, hs);
-        if (!Counter.Sizes.has(hard)) {
-            throw new Error(`Unsupported code ${hard}`);
-        }
-
-        const sizage = Counter.Sizes.get(hard)!;
-        const cs = sizage!.hs + sizage!.ss;
-
-        if (qb64.length < cs) {
-            throw new Error(`Need ${cs - qb64.length} more chars.`);
-        }
-
-        const scount = qb64.slice(sizage.hs, sizage.hs + sizage.ss);
-        const count = b64ToInt(scount);
-
-        this._code = hard;
-        this._count = count;
-    }
-}