signify-ts 0.2.1 → 0.3.0-rc2

package/src/keri/app/habery.ts

@@ -1,185 +0,0 @@
-import { Algos, Manager } from '../core/manager';
-import { MtrDex } from '../core/matter';
-import { Salter } from '../core/salter';
-import { Verfer } from '../core/verfer';
-import { Diger } from '../core/diger';
-import { incept } from '../core/eventing';
-import { Serder } from '../core/serder';
-
-export class TraitCodex {
-    EstOnly: string = 'EO'; // Only allow establishment events
-    DoNotDelegate: string = 'DND'; // Dot not allow delegated identifiers
-    NoBackers: string = 'NB'; // Do not allow backers
-}
-
-export const TraitDex = new TraitCodex();
-
-export interface HaberyArgs {
-    name: string;
-    passcode?: string;
-    seed?: string | undefined;
-    aeid?: string | undefined;
-    pidx?: number | undefined;
-    salt?: string | undefined;
-    tier?: string | undefined;
-}
-
-export interface MakeHabArgs {
-    code?: string;
-    transferable?: boolean;
-    isith?: string;
-    icount?: number;
-    nsith?: string;
-    ncount?: number;
-    toad?: string | number;
-    wits?: Array<string>;
-    delpre?: string;
-    estOnly?: boolean;
-    DnD?: boolean;
-    data?: any;
-}
-
-export class Hab {
-    public name: string;
-    public serder: Serder;
-
-    constructor(name: string, icp: Serder) {
-        this.name = name;
-        this.serder = icp;
-    }
-
-    get pre(): string {
-        return this.serder.ked['i'];
-    }
-}
-
-export class Habery {
-    private readonly _name: string;
-    private readonly _mgr: Manager;
-    private readonly _habs: Map<string, Hab> = new Map<string, Hab>();
-
-    constructor({ name, passcode, seed, aeid, pidx, salt }: HaberyArgs) {
-        this._name = name;
-        if (passcode != undefined && seed == undefined) {
-            if (passcode.length < 21) {
-                throw new Error('Bran (passcode seed material) too short.');
-            }
-
-            const bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21); // qb64 salt for seed
-            const signer = new Salter({ qb64: bran }).signer(
-                MtrDex.Ed25519_Seed,
-                false
-            );
-            seed = signer.qb64;
-            if (aeid == undefined) {
-                aeid = signer.verfer.qb64; // lest it remove encryption
-            }
-        }
-        let algo;
-        const salter =
-            salt != undefined ? new Salter({ qb64: salt }) : undefined;
-        if (salt != undefined) {
-            algo = Algos.salty;
-        } else {
-            algo = Algos.randy;
-        }
-
-        this._mgr = new Manager({
-            seed: seed,
-            aeid: aeid,
-            pidx: pidx,
-            algo: algo,
-            salter: salter,
-        });
-    }
-
-    get mgr(): Manager {
-        return this._mgr;
-    }
-
-    get habs(): Array<Hab> {
-        return Array.from(this._habs.values());
-    }
-
-    habByName(name: string): Hab | undefined {
-        return this._habs.get(name);
-    }
-
-    makeHab(
-        name: string,
-        {
-            code = MtrDex.Blake3_256,
-            transferable = true,
-            isith = undefined,
-            icount = 1,
-            nsith = undefined,
-            ncount = undefined,
-            toad = undefined,
-            wits = undefined,
-            delpre = undefined,
-            estOnly = false,
-            DnD = false,
-            data = undefined,
-        }: MakeHabArgs
-    ): Hab {
-        if (nsith == undefined) {
-            nsith = isith;
-        }
-        if (ncount == undefined) {
-            ncount = icount;
-        }
-        if (!transferable) {
-            ncount = 0;
-            nsith = '0';
-            code = MtrDex.Ed25519N;
-        }
-
-        const [verfers, digers] = this._mgr.incept({
-            icount: icount,
-            ncount: ncount,
-            stem: this.name,
-            transferable: transferable,
-            temp: false,
-        });
-
-        icount = verfers.length;
-        ncount = digers != undefined ? digers.length : 0;
-        if (isith == undefined) {
-            isith = `${Math.max(1, Math.ceil(icount / 2)).toString(16)}`;
-        }
-        if (nsith == undefined) {
-            nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
-        }
-
-        const cnfg = new Array<string>();
-        if (estOnly) {
-            cnfg.push(TraitDex.EstOnly);
-        }
-        if (DnD) {
-            cnfg.push(TraitDex.DoNotDelegate);
-        }
-
-        const keys = Array.from(verfers, (verfer: Verfer) => verfer.qb64);
-        const ndigs = Array.from(digers, (diger: Diger) => diger.qb64);
-
-        const icp = incept({
-            keys,
-            isith,
-            ndigs,
-            nsith,
-            toad,
-            wits,
-            cnfg,
-            data,
-            code,
-            delpre,
-        });
-        const hab = new Hab(name, icp);
-        this._habs.set(name, hab);
-        return hab;
-    }
-
-    get name(): string {
-        return this._name;
-    }
-}

package/src/keri/core/cigar.ts

@@ -1,18 +0,0 @@
-import { Verfer } from './verfer';
-import { Matter, MatterArgs } from './matter';
-
-export class Cigar extends Matter {
-    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 | undefined {
-        return this._verfer;
-    }
-
-    set verfer(verfer: Verfer | undefined) {
-        this._verfer = verfer;
-    }
-}

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;
-}