keri-ts 0.2.3 → 0.3.0

package/esm/app/keeping.js

@@ -0,0 +1,321 @@
+import { blake3 } from "@noble/hashes/blake3";
+import { argon2id } from "@noble/hashes/argon2";
+import { ed25519 } from "@noble/curves/ed25519";
+import { parseMatter } from "cesr-ts";
+const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+export var Algos;
+(function (Algos) {
+    Algos["randy"] = "randy";
+    Algos["salty"] = "salty";
+    Algos["group"] = "group";
+    Algos["extern"] = "extern";
+})(Algos || (Algos = {}));
+function toBase64Url(bytes) {
+    let s = "";
+    for (const b of bytes)
+        s += String.fromCharCode(b);
+    return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function fromBase64Url(text) {
+    const padded = text + "=".repeat((4 - (text.length % 4 || 4)) % 4);
+    const b64 = padded.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = atob(b64);
+    const out = new Uint8Array(decoded.length);
+    for (let i = 0; i < decoded.length; i++)
+        out[i] = decoded.charCodeAt(i);
+    return out;
+}
+function intToB64(value, length = 1) {
+    let v = value;
+    const out = new Array(length).fill("A");
+    for (let i = length - 1; i >= 0; i--) {
+        out[i] = B64_ALPHABET[v & 0x3f];
+        v = Math.floor(v / 64);
+    }
+    return out.join("");
+}
+function parseQb64Raw(qb64) {
+    return parseMatter(new TextEncoder().encode(qb64), "txt").raw;
+}
+function encodeFixedMatter(code, raw) {
+    const cs = code.length;
+    const ps = cs % 4;
+    const body = toBase64Url(new Uint8Array(ps + raw.length).map((_, i) => i < ps ? 0 : raw[i - ps]));
+    return `${code}${body.slice(ps)}`;
+}
+function encodeIndexerEd25519Sig(rawSig, index, ondex = index) {
+    const code = ondex === index ? "A" : "2A";
+    if (code !== "A") {
+        throw new Error("Only compact single-sig indexer encoding is implemented.");
+    }
+    const both = `${code}${intToB64(index, 1)}`;
+    const ps = (3 - (rawSig.length % 3)) % 3;
+    const body = toBase64Url(new Uint8Array(ps + rawSig.length).map((_, i) => i < ps ? 0 : rawSig[i - ps]));
+    return `${both}${body.slice(ps)}`;
+}
+function blake3Qb64(raw, code = "E") {
+    return encodeFixedMatter(code, blake3(raw));
+}
+function randomSaltQb64() {
+    const raw = crypto.getRandomValues(new Uint8Array(16));
+    return encodeFixedMatter("0A", raw);
+}
+function pathToBytes(path) {
+    return new TextEncoder().encode(path);
+}
+function tierParams(tier, temp) {
+    if (temp) {
+        return { t: 1, m: 8 };
+    }
+    if (tier === "low")
+        return { t: 2, m: 65536 };
+    if (tier === "med")
+        return { t: 3, m: 262144 };
+    if (tier === "high")
+        return { t: 4, m: 1048576 };
+    throw new Error(`Unsupported security tier=${tier}`);
+}
+function deriveSeedFromSalt(saltQb64, path, tier, temp) {
+    const saltRaw = parseQb64Raw(saltQb64);
+    const params = tierParams(tier, temp);
+    return argon2id(pathToBytes(path), saltRaw, {
+        p: 1,
+        t: params.t,
+        m: params.m,
+        dkLen: 32,
+        version: 0x13,
+    });
+}
+export function saltySigner(saltQb64, path, transferable, tier, temp) {
+    const seedRaw = deriveSeedFromSalt(saltQb64, path, tier, temp);
+    const seedQb64 = encodeFixedMatter("A", seedRaw);
+    const pubRaw = ed25519.getPublicKey(seedRaw);
+    const verferQb64 = encodeFixedMatter(transferable ? "D" : "B", pubRaw);
+    return { seedQb64, verferQb64 };
+}
+function pubsKey(pre, ridx) {
+    return `${pre}.${ridx.toString(16).padStart(32, "0")}`;
+}
+export class Manager {
+    constructor(args) {
+        Object.defineProperty(this, "_seed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_ks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { ks, seed = "", aeid = "", pidx = 0, algo = Algos.salty, salt = randomSaltQb64(), tier = "low", } = args;
+        this._ks = ks;
+        this._seed = seed;
+        if (this.pidx === null)
+            this.pidx = pidx;
+        if (this.algo === null)
+            this.algo = algo;
+        if (this.salt === null)
+            this.salt = salt;
+        if (this.tier === null)
+            this.tier = tier;
+        this.setup(aeid, seed);
+    }
+    get ks() {
+        return this._ks;
+    }
+    get seed() {
+        return this._seed;
+    }
+    get aeid() {
+        return this.ks.getGbls("aeid") ?? "";
+    }
+    get pidx() {
+        const val = this.ks.getGbls("pidx");
+        if (val === null)
+            return null;
+        return parseInt(val, 16);
+    }
+    set pidx(pidx) {
+        this.ks.pinGbls("pidx", pidx.toString(16));
+    }
+    get algo() {
+        const val = this.ks.getGbls("algo");
+        if (val === null)
+            return null;
+        return val;
+    }
+    set algo(algo) {
+        this.ks.pinGbls("algo", algo);
+    }
+    get salt() {
+        return this.ks.getGbls("salt");
+    }
+    set salt(salt) {
+        this.ks.pinGbls("salt", salt);
+    }
+    get tier() {
+        return this.ks.getGbls("tier");
+    }
+    set tier(tier) {
+        this.ks.pinGbls("tier", tier);
+    }
+    setup(aeid = "", seed = "") {
+        this.updateAeid(aeid, seed);
+    }
+    updateAeid(aeid, seed) {
+        if (aeid) {
+            if (!seed) {
+                throw new Error("Seed required when aeid is set.");
+            }
+            const seedRaw = parseQb64Raw(seed);
+            const derivedAeid = encodeFixedMatter("B", ed25519.getPublicKey(seedRaw));
+            if (derivedAeid !== aeid) {
+                throw new Error(`Seed missing or provided seed not associated with aeid=${aeid}.`);
+            }
+        }
+        this.ks.pinGbls("aeid", aeid);
+        this._seed = seed;
+    }
+    incept(args = {}) {
+        const { icount = 1, ncount = 1, dcode = "E", stem = "", transferable = true, algo, salt, tier, rooted = true, temp = false, } = args;
+        const usedAlgo = rooted
+            ? (algo ?? this.algo ?? Algos.salty)
+            : (algo ?? Algos.salty);
+        if (usedAlgo !== Algos.salty) {
+            throw new Error(`Unsupported key creation algorithm=${usedAlgo}`);
+        }
+        const usedSalt = rooted ? (salt ?? this.salt ?? "") : (salt ?? "");
+        const usedTier = rooted ? (tier ?? this.tier ?? "low") : (tier ?? "low");
+        const pidx = this.pidx ?? 0;
+        const verfers = [];
+        const digers = [];
+        const rootStem = stem || `${pidx.toString(16)}`;
+        for (let i = 0; i < icount; i++) {
+            const path = `${rootStem}${(0).toString(16)}${i.toString(16)}`;
+            const signer = saltySigner(usedSalt, path, transferable, usedTier, temp);
+            verfers.push({ qb64: signer.verferQb64 });
+            this.ks.putPris(signer.verferQb64, signer.seedQb64);
+        }
+        for (let i = 0; i < ncount; i++) {
+            const path = `${rootStem}${(1).toString(16)}${(icount + i).toString(16)}`;
+            const signer = saltySigner(usedSalt, path, transferable, usedTier, temp);
+            const dig = blake3Qb64(new TextEncoder().encode(signer.verferQb64), dcode);
+            digers.push({ qb64: dig });
+            this.ks.putPris(signer.verferQb64, signer.seedQb64);
+        }
+        const pp = {
+            pidx,
+            algo: usedAlgo,
+            salt: usedSalt,
+            stem,
+            tier: usedTier,
+        };
+        const dt = new Date().toISOString();
+        const ps = {
+            old: { pubs: [], ridx: 0, kidx: 0, dt },
+            new: {
+                pubs: verfers.map((v) => v.qb64),
+                ridx: 0,
+                kidx: 0,
+                dt,
+            },
+            nxt: {
+                pubs: digers.map((d) => d.qb64),
+                ridx: 1,
+                kidx: icount,
+                dt,
+            },
+        };
+        const opre = verfers[0].qb64;
+        if (!this.ks.putPres(opre, opre)) {
+            throw new Error(`Already incepted pre=${opre}.`);
+        }
+        if (!this.ks.putPrms(opre, pp)) {
+            throw new Error(`Already incepted prm for pre=${opre}.`);
+        }
+        if (!this.ks.putSits(opre, ps)) {
+            throw new Error(`Already incepted sit for pre=${opre}.`);
+        }
+        this.ks.putPubs(pubsKey(opre, 0), { pubs: ps.new.pubs });
+        this.ks.putPubs(pubsKey(opre, 1), { pubs: ps.nxt.pubs });
+        this.pidx = pidx + 1;
+        return [verfers, digers];
+    }
+    move(oldPre, newPre) {
+        if (oldPre === newPre)
+            return;
+        if (!this.ks.getPres(oldPre)) {
+            throw new Error(`Nonexistent old pre=${oldPre}, nothing to assign.`);
+        }
+        if (this.ks.getPres(newPre)) {
+            throw new Error(`Preexistent new pre=${newPre} may not clobber.`);
+        }
+        const prm = this.ks.getPrms(oldPre);
+        const sit = this.ks.getSits(oldPre);
+        if (!prm || !sit) {
+            throw new Error(`Missing records to move from old pre=${oldPre}.`);
+        }
+        this.ks.putPrms(newPre, prm);
+        this.ks.putSits(newPre, sit);
+        let ri = 0;
+        while (true) {
+            const oldKey = pubsKey(oldPre, ri);
+            const newKey = pubsKey(newPre, ri);
+            const ps = this.ks.getPubs(oldKey);
+            if (ps === null)
+                break;
+            this.ks.putPubs(newKey, ps);
+            ri += 1;
+        }
+        this.ks.pinPres(oldPre, newPre);
+        this.ks.putPres(newPre, newPre);
+    }
+    sign(ser, pubs, indexed = true) {
+        return pubs.map((pub, idx) => {
+            const seedQb64 = this.ks.getPris(pub);
+            if (!seedQb64)
+                throw new Error(`Missing prikey in db for pubkey=${pub}`);
+            const seedRaw = parseQb64Raw(seedQb64);
+            const sigRaw = ed25519.sign(ser, seedRaw);
+            return indexed
+                ? encodeIndexerEd25519Sig(sigRaw, idx, idx)
+                : encodeFixedMatter("0B", sigRaw);
+        });
+    }
+}
+export function normalizeSaltQb64(salt) {
+    return salt ? encodeFixedMatter("0A", parseQb64Raw(salt)) : randomSaltQb64();
+}
+export function branToSaltQb64(bran) {
+    if (bran.length < 21) {
+        throw new Error("Bran (passcode seed material) too short.");
+    }
+    return `0AA${bran.slice(0, 21)}`;
+}
+export function encodeDateTimeToDater(dts) {
+    return `1AAG${dts.replace(/:/g, "c").replace(/\./g, "d").replace(/\+/g, "p")}`;
+}
+export function encodeCounterV1(code, count) {
+    return `${code}${intToB64(count, 2)}`;
+}
+export function encodeHugeNumber(num) {
+    const raw = new Uint8Array(16);
+    let value = BigInt(num);
+    for (let i = 15; i >= 0; i--) {
+        raw[i] = Number(value & 0xffn);
+        value >>= 8n;
+    }
+    return encodeFixedMatter("0A", raw);
+}
+export function normalizeQb64Code(qb64) {
+    return encodeFixedMatter(parseMatter(new TextEncoder().encode(qb64), "txt").code, parseQb64Raw(qb64));
+}
+export function makeSaider(raw) {
+    return blake3Qb64(raw, "E");
+}
+export function b64DecodeUrl(text) {
+    return fromBase64Url(text);
+}

package/esm/app/version.js

@@ -2,8 +2,8 @@
  * Generated by scripts/generate_versions.ts.
  * Do not edit by hand.
  */
-export const PACKAGE_VERSION = "0.2.3";
-export const BUILD_METADATA = "build.2.ae619744";
+export const PACKAGE_VERSION = "0.3.0";
+export const BUILD_METADATA = "build.3.9b643722";
 export const DISPLAY_VERSION = BUILD_METADATA
     ? `${PACKAGE_VERSION}+${BUILD_METADATA}`
     : PACKAGE_VERSION;

package/esm/db/basing.js

@@ -32,6 +32,24 @@ export class Baser {
             writable: true,
             value: void 0
         }); // Events sub-database (dgKey: serialized KEL events)
+        Object.defineProperty(this, "habs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Habitat records keyed by pre
+        Object.defineProperty(this, "names", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // (ns,name) -> pre
+        Object.defineProperty(this, "hbys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Habery-scoped values such as __signatory__
         this.logger = options.logger ?? consoleLogger;
         // Create LMDBer with composition
         this.lmdber = new LMDBer(options, {
@@ -71,6 +89,9 @@ export class Baser {
         // Names end with "." to avoid namespace collisions with Base64 identifier prefixes
         try {
             this.evts = this.lmdber.openDB("evts.", false);
+            this.habs = this.lmdber.openDB("habs.", false);
+            this.names = this.lmdber.openDB("names.", false);
+            this.hbys = this.lmdber.openDB("hbys.", false);
             return this.opened;
         }
         catch (error) {
@@ -135,6 +156,50 @@ export class Baser {
     *getAllEvtsIter(top = new Uint8Array(0)) {
         yield* this.lmdber.getTopItemIter(this.evts, top);
     }
+    encodeText(text) {
+        return new TextEncoder().encode(text);
+    }
+    decodeText(bytes) {
+        if (bytes === null)
+            return null;
+        return new TextDecoder().decode(bytes);
+    }
+    encodeJson(value) {
+        return this.encodeText(JSON.stringify(value));
+    }
+    decodeJson(bytes) {
+        const text = this.decodeText(bytes);
+        if (text === null)
+            return null;
+        return JSON.parse(text);
+    }
+    putHab(pre, record) {
+        return this.lmdber.putVal(this.habs, this.encodeText(pre), this.encodeJson(record));
+    }
+    pinHab(pre, record) {
+        return this.lmdber.setVal(this.habs, this.encodeText(pre), this.encodeJson(record));
+    }
+    getHab(pre) {
+        return this.decodeJson(this.lmdber.getVal(this.habs, this.encodeText(pre)));
+    }
+    putName(ns, name, pre) {
+        const key = `${ns}:${name}`;
+        return this.lmdber.putVal(this.names, this.encodeText(key), this.encodeText(pre));
+    }
+    pinName(ns, name, pre) {
+        const key = `${ns}:${name}`;
+        return this.lmdber.setVal(this.names, this.encodeText(key), this.encodeText(pre));
+    }
+    getName(ns, name) {
+        const key = `${ns}:${name}`;
+        return this.decodeText(this.lmdber.getVal(this.names, this.encodeText(key)));
+    }
+    pinHby(name, value) {
+        return this.lmdber.setVal(this.hbys, this.encodeText(name), this.encodeText(value));
+    }
+    getHby(name) {
+        return this.decodeText(this.lmdber.getVal(this.hbys, this.encodeText(name)));
+    }
 }
 // Class constants
 Object.defineProperty(Baser, "TailDirPath", {
@@ -147,7 +212,7 @@ Object.defineProperty(Baser, "AltTailDirPath", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: ".keri/db"
+    value: ".tufa/db"
 });
 Object.defineProperty(Baser, "TempPrefix", {
     enumerable: true,

package/esm/db/core/lmdber.js

@@ -23,8 +23,8 @@ export const LMDBER_DEFAULTS = {
     tailDirPath: "keri/db",
     cleanTailDirPath: "keri/clean/db",
     altHeadDirPath: "~",
-    altTailDirPath: ".keri/db",
-    altCleanTailDirPath: ".keri/clean/db",
+    altTailDirPath: ".tufa/db",
+    altCleanTailDirPath: ".tufa/clean/db",
     tempHeadDir: "/tmp",
     tempPrefix: "keri_lmdb_",
     tempSuffix: "_test",
@@ -111,7 +111,9 @@ export class LMDBer {
         });
     }
     /**
-     * Reopen the LMDB database
+     * Reopen the LMDB database. LMDBer relies on PathManager to create the containing directory and
+     * then the LMDB library creates the data.mdb and lock.mdb files.
+     *
      * Closes existing database if open before opening a new one to prevent double-free errors
      */
     *reopen(options = {}) {
@@ -192,14 +194,18 @@ export class LMDBer {
         }
     }
     /**
-     * Check if database already exists by checking for database files
+     * Check if database files exist in the path directory
+     * LMDB creates data.mdb and lock.mdb files. lock.mdb might not exist if there are no active transactions
+     * Returns Effection Operation with true if data.mdb exists
      */
     *checkDatabaseExists() {
         if (!this.pathManager.path) {
             return false;
         }
         // Check if database files exist (now an Effection operation)
-        return yield* this.pathManager.databaseFilesExist();
+        const dataMdbPath = `${this.path}/data.mdb`;
+        const pathStat = yield* this.pathManager.statFileOp(dataMdbPath);
+        return pathStat.isFile ?? false;
     }
     /**
      * Close the LMDB database
@@ -440,13 +446,13 @@ Object.defineProperty(LMDBer, "AltTailDirPath", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: ".keri/db"
+    value: ".tufa/db"
 });
 Object.defineProperty(LMDBer, "AltCleanTailDirPath", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: ".keri/clean/db"
+    value: ".tufa/clean/db"
 });
 Object.defineProperty(LMDBer, "TempHeadDir", {
     enumerable: true,