@keri-ts/wallet 0.0.0-stage → 2.0.1

package/esm/wallet/npm/src/src/storing.js

@@ -0,0 +1,60 @@
+import { Komer, LMDBer, Suber } from "keri-ts/db";
+import { DatabaseNotOpenError, RawRecord } from "keri-ts/runtime";
+/** Komer hydration of issued application records. */
+export class IssuedRecord extends RawRecord {
+}
+/** Komer hydration of explicit consent records. */
+export class AdmittedRecord extends RawRecord {
+}
+/** Own only wallet inventory; protocol acceptance remains in the borrowed processors. */
+export class WalletBaser extends LMDBer {
+    constructor(options = {}) {
+        super(options, {
+            tailDirPath: "keri/wallet",
+            cleanTailDirPath: "keri/clean/wallet",
+            altTailDirPath: ".tufa/wallet",
+            altCleanTailDirPath: ".tufa/clean/wallet",
+            tempPrefix: "keri_wallet_",
+        });
+        Object.defineProperty(this, "issued", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "admitted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    /** Rebind the application's ordinary typed tables on joined reopen. */
+    *reopen(options = {}) {
+        if (!(yield* super.reopen(options)))
+            return false;
+        try {
+            this.issued = new Komer(this, { subkey: "issued.", recordClass: IssuedRecord });
+            this.admitted = new Komer(this, { subkey: "admitted.", recordClass: AdmittedRecord });
+            this.credentials = new Suber(this, { subkey: "credential-grants." });
+            return true;
+        }
+        catch (error) {
+            yield* this.close();
+            throw error;
+        }
+    }
+}
+/** Acquire a wallet environment; callers join close after all borrowed users finish. */
+export function* createWalletBaser(options = {}) {
+    const db = new WalletBaser(options);
+    if (!(yield* db.reopen()))
+        throw new DatabaseNotOpenError("Wallet environment could not open.");
+    return db;
+}

package/esm/wallet/npm/src/src/wallet.js

@@ -0,0 +1,251 @@
+/** Explicit ACDC inventory and consent over borrowed authenticated protocol evidence. */
+import { bytesEqual, collectPayload, nestedPayload, SerderACDC, Vrsn_2_0, } from "cesr-ts";
+import { call } from "effection";
+import { loadNests } from "keri-ts/db";
+import { acceptedRegistryEvidence, authenticateIpexNode, envelopeFromFrame, evaluateChain, ipexExnBody, isLocalGroupHab, issuedNodeVerdict, ValidationError, vet, walkIpexGraph, } from "keri-ts/runtime";
+import { Buffer } from "node:buffer";
+import { anchorExchange, exchangeWire, WalletDiscloser } from "./disclosing.js";
+/** Compare durable application values, including exact originally issued raw bytes. */
+function identical(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+/** Inventory owns consent, never protocol acceptance, current standing or custody. */
+export class Wallet {
+    constructor({ hby, registry, exc, db }) {
+        Object.defineProperty(this, "hby", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "registry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "exc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (exc.hby !== hby)
+            throw new ValidationError("Wallet requires its actual Exchanger.");
+        this.hby = hby;
+        this.registry = registry;
+        this.exc = exc;
+        this.db = db;
+    }
+    /** Verify accepted local issuance, or return identical retained history without fresh proof. */
+    recordIssued(acdc, update, { blinder } = {}) {
+        const event = this.registry.event(update);
+        const regid = acdc.regid ?? (typeof event?.sad?.rd === "string" ? event.sad.rd : null);
+        const chain = regid ? acceptedRegistryEvidence(this.registry, regid) : null;
+        if (!event || !chain || !this.hby.habs.has(chain.rip.issuer)) {
+            throw new ValidationError("Local accepted issuance evidence is required.");
+        }
+        const index = chain.updates.findIndex((item) => item.said === update);
+        if (index < 0)
+            throw new ValidationError("Issuance update is still pending.");
+        const old = this.db.issued.get([acdc.said]);
+        const raw = Buffer.from(acdc.raw).toString("base64");
+        if (old && !blinder) {
+            const expected = {
+                credential: acdc.said,
+                registry: regid,
+                controller: chain.rip.issuer,
+                update,
+                raw,
+                encoding: "base64",
+                bound: old.bound,
+            };
+            if (!identical(old, expected))
+                throw new ValidationError("Different issuance is already retained.");
+            return old;
+        }
+        if (event.ilk === "bup" && !blinder) {
+            throw new ValidationError("Fresh blinded issuance requires an explicit opening.");
+        }
+        if (blinder && event.ilk !== "bup")
+            throw new ValidationError("Opening requires a blinded update.");
+        const verified = vet({ ...chain, updates: chain.updates.slice(0, index + 1), db: this.hby.db, acdc, blinder });
+        if (verified.kind !== "verified" || verified.state.state !== "issued") {
+            throw new ValidationError("Referenced update does not prove issued state.");
+        }
+        const record = {
+            credential: acdc.said,
+            registry: regid,
+            controller: chain.rip.issuer,
+            update,
+            raw,
+            encoding: "base64",
+            bound: blinder && "bn" in blinder ? { bn: blinder.bn.num.toString(16), bd: blinder.bd.qb64 } : null,
+        };
+        if (old && !identical(old, record))
+            throw new ValidationError("Different issuance is already retained.");
+        this.db.issued.put([acdc.said], record);
+        return this.db.issued.get([acdc.said]);
+    }
+    /** Reconstruct the original serialization without asserting present registry standing. */
+    issuedCredential(said) {
+        const record = this.db.issued.get([said]);
+        if (!record || record.encoding !== "base64")
+            throw new ValidationError("Issued credential is required.");
+        const raw = new Uint8Array(Buffer.from(record.raw, "base64"));
+        const acdc = new SerderACDC({ raw });
+        if (Buffer.from(raw).toString("base64") !== record.raw || acdc.said !== said || !bytesEqual(acdc.raw, raw)) {
+            throw new ValidationError("Retained issuance bytes do not match their identifier.");
+        }
+        return acdc;
+    }
+    /** Authenticate accepted outer evidence through existing replay, without current node policy. */
+    async accepted(said, route) {
+        const body = this.hby.db.exns.get([said]);
+        if (!body || body.said !== said || body.route !== route || body.pvrsn.major !== 2 || !this.exc.complete(said)) {
+            throw new ValidationError("Accepted ACDC v2 exchange at the exact route is required.");
+        }
+        for await (const _chunk of this.exc.replay(said)) { /* replay authenticates retained outer factors */ }
+        return body;
+    }
+    /** New use requires current node evidence and a valid root under shared issued-state policy. */
+    graphAccepted(grant, origin) {
+        if (!this.exc.verifyAccepted(grant, "/ipex/grant"))
+            return false;
+        const graph = walkIpexGraph(origin, loadNests(this.hby.db, grant), true);
+        if (!graph)
+            return false;
+        const verdicts = new Map();
+        for (const [said, node] of graph.nodes) {
+            const auth = authenticateIpexNode(node.body, envelopeFromFrame(node), this.hby.db, this.registry);
+            verdicts.set(said, issuedNodeVerdict(auth));
+        }
+        return evaluateChain(graph, verdicts, this.hby.db)?.kind === "valid";
+    }
+    /** Resolve only the origin actually carried by this accepted Grant. */
+    origin(grant) {
+        const origins = grant.sad.a && grant.sad.a.o;
+        if (!Array.isArray(origins) || origins.length !== 1 || typeof origins[0] !== "string") {
+            throw new ValidationError("Wallet admission requires one disclosed origin.");
+        }
+        if (!loadNests(this.hby.db, grant.said).some((node) => node.body instanceof SerderACDC && node.body.said === origins[0])) {
+            throw new ValidationError("Accepted Grant origin is missing.");
+        }
+        return origins[0];
+    }
+    /** Freeze an unsigned response only after explicit consent, exact prior authentication and current root truth. */
+    *prepareAdmitBody(grant, holder, { consent = false, message = "", gvrsn = Vrsn_2_0 } = {}) {
+        if (consent !== true)
+            throw new ValidationError("Explicit consent is required.");
+        if (gvrsn.major < 2)
+            throw new ValidationError("ACDC v2 Admit requires attachment genus 2 or later.");
+        const g = yield* call(() => this.accepted(grant, "/ipex/grant")), hab = this.hby.habs.get(holder);
+        if (!hab || g.sad.ri !== holder)
+            throw new ValidationError("Grant must address the intended local holder.");
+        const response = this.hby.db.erpy.get([grant]);
+        if (response && this.exc.complete(response.qb64)) {
+            throw new ValidationError("Grant already has an accepted response.");
+        }
+        if (!this.graphAccepted(grant, this.origin(g))) {
+            throw new ValidationError("Current authenticated graph acceptance is required before signing.");
+        }
+        return ipexExnBody(holder, "/ipex/admit", [], { message, prior: g, gvrsn });
+    }
+    /** Sign an individual response; group approval consumes the same unsigned body through its own exact-stream owner. */
+    *prepareAdmit(grant, holder, { consent = false, message = "", gvrsn = Vrsn_2_0, receiptor, auths } = {}) {
+        if (consent !== true)
+            throw new ValidationError("Explicit consent is required.");
+        if (gvrsn.major < 2)
+            throw new ValidationError("ACDC v2 Admit requires attachment genus 2 or later.");
+        const hab = this.hby.habs.get(holder);
+        if (!hab)
+            throw new ValidationError("Grant must address the intended local holder.");
+        if (isLocalGroupHab(this.hby, hab)) {
+            throw new ValidationError("ACDC v2 wallet admission requires a single-signature holder.");
+        }
+        const admit = yield* this.prepareAdmitBody(grant, holder, { consent, message, gvrsn });
+        const anchored = admit.sad.a.ax?.[0] === true;
+        if (anchored && !receiptor)
+            throw new ValidationError("Anchored Admit requires its actual receipt owner.");
+        const source = anchored ? yield* anchorExchange(this, receiptor, hab, admit, auths) : undefined;
+        if (!this.graphAccepted(grant, this.origin(this.hby.db.exns.get([grant])))) {
+            throw new ValidationError("Current authenticated graph acceptance is required after source receipts.");
+        }
+        return {
+            admit,
+            wire: exchangeWire(hab, admit, undefined, source, gvrsn),
+            support: source ? new WalletDiscloser(this, receiptor).kel(hab) : new Uint8Array(),
+        };
+    }
+    /** Record explicit local consent to one accepted, linked Grant/Admit pair. */
+    async recordAdmission(grant, admit, { consent = false } = {}) {
+        if (consent !== true)
+            throw new ValidationError("Explicit consent is required.");
+        const g = await this.accepted(grant, "/ipex/grant"), a = await this.accepted(admit, "/ipex/admit");
+        const holder = g.sad.ri;
+        if (typeof holder !== "string" || !this.hby.habs.has(holder) || a.pre !== holder || a.sad.p !== grant
+            || a.sad.ri !== g.pre || this.hby.db.erpy.get([grant])?.qb64 !== admit) {
+            throw new ValidationError("Admit must be the intended local holder response to this Grant.");
+        }
+        const origin = this.origin(g);
+        const old = this.db.admitted.get([grant]);
+        if (old) {
+            if (old.admit !== admit || old.credential !== origin || old.holder !== holder) {
+                throw new ValidationError("Conflicting wallet admission.");
+            }
+            return old;
+        }
+        if (!this.exc.verifyAccepted(admit, "/ipex/admit") || !this.graphAccepted(grant, origin)) {
+            throw new ValidationError("Current authenticated graph acceptance is required for new admission.");
+        }
+        const record = { credential: origin, grant, admit, holder, admitted: new Date().toISOString() };
+        this.db.env.transactionSync(() => {
+            this.db.admitted.put([grant], record);
+            this.db.credentials.put([origin, grant], grant);
+        });
+        return this.db.admitted.get([grant]);
+    }
+    /** Read the original admitted proof; later disclosures and current policy cannot expand it. */
+    async heldCredential(grant, { presenterAuthorized = false } = {}) {
+        const record = this.db.admitted.get([grant]);
+        if (!record && presenterAuthorized !== true) {
+            throw new ValidationError("Grant has not been admitted; a transferred view requires explicit presenter authorization.");
+        }
+        const body = await this.accepted(grant, "/ipex/grant");
+        const admit = record?.admit ?? this.hby.db.erpy.get([grant])?.qb64;
+        if (!admit)
+            throw new ValidationError("Transferred Grant requires its exact accepted Admit.");
+        const response = await this.accepted(admit, "/ipex/admit");
+        if (response.sad.p !== grant || response.pre !== body.sad.ri) {
+            throw new ValidationError("Transferred Admit does not match the exact view.");
+        }
+        const nests = loadNests(this.hby.db, grant);
+        const origin = nests.find((node) => node.body instanceof SerderACDC && node.body.said === (record?.credential ?? this.origin(body)));
+        if (!origin)
+            throw new ValidationError("Admitted origin evidence is missing.");
+        return {
+            credential: origin.body,
+            proof: await collectPayload(nestedPayload(origin, Vrsn_2_0)),
+            artifacts: await Promise.all(nests.filter((node) => node !== origin).map((node) => collectPayload(nestedPayload(node, Vrsn_2_0)))),
+            grant: body,
+            admit,
+        };
+    }
+    /** List historical references, with no current-standing or private-capability claim. */
+    inventory() {
+        return {
+            issued: [...this.db.issued.getTopItemIter()].map(([, row]) => row),
+            held: [...this.db.admitted.getTopItemIter()].map(([, row]) => row),
+        };
+    }
+    /** List distinct explicit disclosure admissions for the same credential. */
+    admissions(credential) {
+        return [...this.db.credentials.getTopItemIter([credential])].map(([, grant]) => this.db.admitted.get([grant]));
+    }
+}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@keri-ts/wallet",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.1",
+  "description": "Explicit local ACDC credential inventory and admission",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kentbull/keri-ts.git",
+    "directory": "packages/wallet"
+  },
+  "license": "Apache-2.0",
+  "main": "./esm/wallet/npm/src/mod.js",
+  "module": "./esm/wallet/npm/src/mod.js",
+  "types": "./types/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/mod.d.ts",
+      "import": "./esm/wallet/npm/src/mod.js"
+    }
+  },
+  "scripts": {
+    "test": "node --version"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "esm",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.3"
+  },
+  "dependencies": {
+    "cesr-ts": "2.0.0",
+    "effection": "^3.6.0",
+    "keri-ts": "2.0.1",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/types/mod.d.ts

@@ -0,0 +1,7 @@
+/** Wallet application entrypoint; public protocol owners remain borrowed from keri-ts. */
+export { type AcdcV2UpdateOptions, WalletAuthor } from "./src/authoring.js";
+export { RegistryCustody } from "./src/custody.js";
+export { type DisclosureSelection, exchangeWire, type GrantFileSelection, type InspectedGrantFile, type IssuanceGrantOptions, type PreparedDisclosure, type PreparedGrantBody, WalletDiscloser, } from "./src/disclosing.js";
+export { type AdmittedCredential, createWalletBaser, type IssuedCredential, WalletBaser } from "./src/storing.js";
+export { type HeldCredential, type PreparedAdmit, Wallet, type WalletOptions } from "./src/wallet.js";
+//# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,OAAO,EAAE,KAAK,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EACL,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,kBAAkB,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAClH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/types/src/authoring.d.ts

@@ -0,0 +1,51 @@
+/** Finite ACDC v2 registry authoring; existing engines own acceptance and receipt authentication. */
+import { type SerderACDC } from "cesr-ts";
+import type { Operation } from "effection";
+import { type AcdcMapOptions, type AcdcV2Regery, type AcdcV2Registry, type Receiptor, type RegistryDisclosure, type WitnessAuthMap } from "keri-ts/runtime";
+import type { RegistryCustody } from "./custody.js";
+import type { Wallet } from "./wallet.js";
+/** Public means deliberate opening publication; private derivation requires supplied custody. */
+export interface AcdcV2UpdateOptions {
+    public?: boolean;
+    stamp?: string;
+    boundEvent?: string;
+    /** Transient witness codes for this operation; never retained with registry evidence. */
+    auths?: WitnessAuthMap;
+}
+/** Borrow the actual wallet, registry environment and receipt collector; acquire no handles or workers. */
+export declare class WalletAuthor {
+    readonly wallet: Wallet;
+    readonly rgy: AcdcV2Regery;
+    readonly receiptor: Receiptor;
+    readonly custody?: RegistryCustody | undefined;
+    constructor(wallet: Wallet, rgy: AcdcV2Regery, receiptor: Receiptor, custody?: RegistryCustody | undefined);
+    /** Resolve the actual local registry; staging supports groups while signing methods enforce their owner. */
+    registry(name: string, controller: string): AcdcV2Registry;
+    /** Signing belongs either to this individual owner or to explicit group approval, never a staging flag. */
+    private individual;
+    /** Idempotently stage an alias, then return only its exact accepted inception. */
+    incept(name: string, controller: string, auths?: WitnessAuthMap): Operation<SerderACDC>;
+    /** Construct the issuer's credential using the existing ACDC v2 finite builder. */
+    create(reg: AcdcV2Registry, options: Omit<AcdcMapOptions, "regid">): SerderACDC;
+    /** Stage one BUP state advance, preserving an exact pending retry and its opening. Never author historical upd. */
+    stage(reg: AcdcV2Registry, acdc: SerderACDC, state: string, options?: AcdcV2UpdateOptions): {
+        event: SerderACDC;
+        opening: RegistryDisclosure;
+    };
+    /** Ensure revocation of retained local issuance; an identical accepted revocation remains an idempotent retry. */
+    stageRevocation(reg: AcdcV2Registry, said: string, options?: AcdcV2UpdateOptions): {
+        event: SerderACDC;
+        opening: RegistryDisclosure;
+    };
+    /** Share validation and exact pending-next reuse; only the concrete revocation ensure operation can reuse an accepted head. */
+    private stageState;
+    /** Advance one explicit state through real anchoring; staging is never reported as accepted. */
+    update(reg: AcdcV2Registry, acdc: SerderACDC, state: string, options?: AcdcV2UpdateOptions): Operation<SerderACDC>;
+    /** Preserve original issued history on retry; inventory follows exact witnessed TEL acceptance. */
+    issue(reg: AcdcV2Registry, acdc: SerderACDC, options?: AcdcV2UpdateOptions): Generator<import("effection").Instruction, import("./storing.js").IssuedCredential, any>;
+    /** Revoke only locally retained issuance, not an unrelated arbitrary target digest. */
+    revoke(reg: AcdcV2Registry, said: string, options?: AcdcV2UpdateOptions): Operation<SerderACDC>;
+    /** Reuse the current branch's already signed seal even before receipts; no extra anchor merely to poll. */
+    anchor(reg: AcdcV2Registry, event: SerderACDC, auths?: WitnessAuthMap): Operation<void>;
+}
+//# sourceMappingURL=authoring.d.ts.map

package/types/src/authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../src/src/authoring.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,OAAO,EAA8B,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,SAAS,EACd,KAAK,kBAAkB,EAGvB,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,iGAAiG;AACjG,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yFAAyF;IACzF,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED,2GAA2G;AAC3G,qBAAa,YAAY;IAErB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,GAAG,EAAE,YAAY;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe;gBAHzB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,eAAe,YAAA;IAcpC,4GAA4G;IAC5G,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc;IAQ1D,2GAA2G;IAC3G,OAAO,CAAC,UAAU;IAMlB,kFAAkF;IACjF,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC;IAYxF,mFAAmF;IACnF,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG,UAAU;IAK/E,mHAAmH;IACnH,KAAK,CACH,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,GAChC;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAA;KAAE;IAIrD,kHAAkH;IAClH,eAAe,CACb,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAwB,GAChC;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAA;KAAE;IAQrD,+HAA+H;IAC/H,OAAO,CAAC,UAAU;IAiFlB,gGAAgG;IAC/F,MAAM,CACL,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,GAChC,SAAS,CAAC,UAAU,CAAC;IAOxB,mGAAmG;IAClG,KAAK,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,GAAE,mBAAwB;IAW/E,uFAAuF;IACtF,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,SAAS,CAAC,UAAU,CAAC;IAOpG,2GAA2G;IAC1G,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC,IAAI,CAAC;CA4BzF"}

package/types/src/custody.d.ts

@@ -0,0 +1,53 @@
+/** Optional encrypted derivation capability; ordinary wallet inventory never constructs or reads it. */
+import { type SerderACDC } from "cesr-ts";
+import { type RegistryStore } from "keri-ts/db";
+import { type Hab, type Habery, type RegistryDisclosure } from "keri-ts/runtime";
+import type { WalletBaser } from "./storing.js";
+interface DerivedUpdate {
+    credential: string;
+    state: string;
+    bound: {
+        bn: string;
+        bd: string;
+    } | null;
+}
+/** Explicit capability over an existing wallet environment and accepted public registry evidence. */
+export declare class RegistryCustody {
+    readonly options: {
+        hby: Habery;
+        hab: Hab;
+        registry: RegistryStore;
+        db: WalletBaser;
+    };
+    private env;
+    private derivations?;
+    /** Borrow owners only; construction opens no table and loads no encrypted row. */
+    constructor(options: {
+        hby: Habery;
+        hab: Hab;
+        registry: RegistryStore;
+        db: WalletBaser;
+    });
+    /** Bind the actual local habitat and its key owners, never an AID label alone. */
+    private owner;
+    /** Rebind optional tables after the caller reopens the same wallet owner. */
+    private tables;
+    /** Load only this habitat's Keeper root; possession confers no protocol authority. */
+    private load;
+    /** Provision an issuer-selected root once, refusing replacement behind opaque accepted history. */
+    createCustody(registry: string): {
+        registry: string;
+    };
+    /** Derive a candidate only; consumers still authenticate its exact accepted event and bound KEL reference. */
+    derive(registry: string, ordinal: number | bigint, credential: string, state: string, options?: {
+        bound?: boolean;
+        bsn?: number | bigint;
+        bd?: string;
+    }): RegistryDisclosure;
+    /** Persist exact nonsecret coordinates before processing/anchoring a newly derived BUP. */
+    retainDerivedUpdate(event: SerderACDC, opening: RegistryDisclosure): DerivedUpdate;
+    /** Reproduce only the exact accepted event, never today's head or a later credential's coordinates. */
+    derivedOpening(event: SerderACDC): RegistryDisclosure;
+}
+export {};
+//# sourceMappingURL=custody.d.ts.map

package/types/src/custody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custody.d.ts","sourceRoot":"","sources":["../../src/src/custody.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,OAAO,EAA8D,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACtG,OAAO,EAAS,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,MAAM,EAAa,KAAK,kBAAkB,EAA6B,MAAM,iBAAiB,CAAC;AACvH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,UAAU,aAAa;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAC1C;AASD,qGAAqG;AACrG,qBAAa,eAAe;IAKd,QAAQ,CAAC,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,aAAa,CAAC;QAAC,EAAE,EAAE,WAAW,CAAA;KAAE;IAJjG,OAAO,CAAC,GAAG,CAA4B;IACvC,OAAO,CAAC,WAAW,CAAC,CAAuB;IAE3C,kFAAkF;gBAC7D,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,aAAa,CAAC;QAAC,EAAE,EAAE,WAAW,CAAA;KAAE;IAIjG,kFAAkF;IAClF,OAAO,CAAC,KAAK;IAOb,6EAA6E;IAC7E,OAAO,CAAC,MAAM;IAUd,sFAAsF;IACtF,OAAO,CAAC,IAAI;IAOZ,mGAAmG;IACnG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;IAiCrD,8GAA8G;IAC9G,MAAM,CACJ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAO,GACpE,kBAAkB;IAarB,2FAA2F;IAC3F,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,kBAAkB,GAAG,aAAa;IAiBlF,uGAAuG;IACvG,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB;CAwBtD"}

package/types/src/disclosing.d.ts

@@ -0,0 +1,109 @@
+/** Finite ACDC v2 IPEX composition over exact wallet views and explicitly supplied private capability. */
+import { type CesrFrame, SealSource, SerderACDC, SerderKERI, type Versionage } from "cesr-ts";
+import { type Operation } from "effection";
+import { type AcdcV2Registry, type Hab, type IpexV2BodyOptions, type Receiptor, type RegistryDisclosure, type WitnessAuthMap } from "keri-ts/runtime";
+import type { RegistryCustody } from "./custody.js";
+import type { Wallet } from "./wallet.js";
+/** A prepared signed exchange and its supporting public KEL/TEL bytes; delivery and intake stay explicit. */
+export interface PreparedDisclosure {
+    exn: SerderKERI;
+    wire: Uint8Array;
+    support: Uint8Array;
+}
+/** Frozen unsigned Grant and its exact selected nodes; group approval and presentation anchoring remain explicit. */
+export interface PreparedGrantBody {
+    exn: SerderKERI;
+    raw: Uint8Array;
+    nests: Uint8Array;
+}
+/** Exact parties reviewed by the operator before adding independent issuer authentication. */
+export interface GrantFileSelection {
+    said: string;
+    sender: string;
+    recipient: string;
+}
+/** Valid individual factors may remain below their ordinary signing threshold. */
+export interface InspectedGrantFile {
+    frame: CesrFrame;
+    completeSigners: string[];
+    partialSigners: string[];
+}
+/** Fresh origin and explicit far-node proofs; preparation grants neither DH nor inventory consent. */
+export interface IssuanceGrantOptions extends Omit<IpexV2BodyOptions, "prior"> {
+    recipient: string;
+    priorSaid?: string;
+    artifacts?: readonly Uint8Array[];
+}
+/** Select an exact issued credential or a retained Grant, never the fullest cached credential. */
+export interface DisclosureSelection {
+    said?: string;
+    fromGrant?: string;
+    /** Exact transferred credential/proof bytes; explicit presenter authorization creates no inventory consent. */
+    transferred?: Uint8Array;
+    presenterAuthorized?: boolean;
+    disclose?: readonly string[];
+    refresh?: boolean;
+    openings?: readonly RegistryDisclosure[];
+    derive?: boolean;
+    artifacts?: readonly Uint8Array[];
+}
+/** Reuse a matching accepted KEL seal, or author once and gather real witness receipts. */
+export declare function anchorExchange(wallet: Wallet, receiptor: Receiptor, hab: Hab, body: SerderKERI | SerderACDC, auths?: WitnessAuthMap): Operation<SealSource>;
+/** Encode one frozen body and its existing prepared nests; source proofs do not alter its SAID. */
+export declare function exchangeWire(hab: Hab, exn: SerderKERI, nested?: Uint8Array, source?: SealSource, gvrsn?: Versionage): Uint8Array;
+/** Borrow concrete owners only. No constructor opens a store, starts a worker or loads registry secrets. */
+export declare class WalletDiscloser {
+    readonly wallet: Wallet;
+    readonly receiptor: Receiptor;
+    readonly custody?: RegistryCustody | undefined;
+    constructor(wallet: Wallet, receiptor: Receiptor, custody?: RegistryCustody | undefined);
+    /** Resolve only a local individual signer; group approval composes this body in the group workflow. */
+    private signer;
+    /** Revalidate exact accepted prior bytes without treating notification or salt possession as acceptance. */
+    private prior;
+    /** Reduce only the selected attribute view using the existing commitment-preserving Compactor. */
+    private partial;
+    /** Authenticate every selected node, then authorize only the shared complete-root expression. */
+    private requireGraph;
+    /** Recover a candidate using an explicitly possessed UUID; this neither derives a salt nor grants authority. */
+    unblind(opening: RegistryDisclosure, credential: string, states: readonly string[], bounds?: readonly (readonly [number | bigint, string])[]): RegistryDisclosure | null;
+    /** Attach exact accepted issuer openings from head through vacuous suffix to this credential's binding. */
+    registryProof(credential: SerderACDC, registry: string, retained?: readonly RegistryDisclosure[], options?: Pick<DisclosureSelection, "derive">): Uint8Array;
+    /** Select immutable admitted/transferred nests; proof refresh changes attachments only when explicitly requested. */
+    private selected;
+    /** Create an application request; no credential-use approval is invented for negotiation. */
+    prepareApply(sender: string, options: IpexV2BodyOptions): Operation<PreparedDisclosure>;
+    /** Offer only the selected commitment/view without issuer proof attachments. */
+    prepareOffer(sender: string, selection: DisclosureSelection, options: IpexV2BodyOptions & {
+        priorSaid?: string;
+    }): Operation<PreparedDisclosure>;
+    /** Accept or decline the exact authenticated predecessor and its negotiated anchoring choice. */
+    prepareReply(sender: string, verb: "agree" | "spurn", priorSaid: string, message?: string, recipient?: string, auths?: WitnessAuthMap): Operation<PreparedDisclosure>;
+    /** Select and authorize once before freezing a Grant body, without signing or committing group approval. */
+    prepareGrantBody(sender: string, selection: DisclosureSelection, options: IpexV2BodyOptions & {
+        priorSaid?: string;
+    }): Operation<PreparedGrantBody>;
+    /** Freeze an endorsement file from issued evidence, allowing only retryable current-opening absence. */
+    prepareGrantFileBody(sender: string, selection: DisclosureSelection, options: IpexV2BodyOptions & {
+        priorSaid?: string;
+    }): Operation<PreparedGrantBody>;
+    /** Both public preparation profiles preserve the same selected view and body construction. */
+    private grantBody;
+    /** Inspect one exact unanchored Grant without dropping invalid signatures or publishing any evidence. */
+    inspectGrantFile(raw: Uint8Array, selection?: GrantFileSelection): InspectedGrantFile;
+    /** Prepare one fresh issuer origin with explicit authenticated far nodes, without changing disclosure authority. */
+    prepareIssuanceGrantBody(sender: string, credential: SerderACDC, options: IssuanceGrantOptions): Operation<PreparedGrantBody>;
+    /** Extend the frozen Grant's exact origin proof; ordinary intake still authenticates the supplied presentation evidence. */
+    attachPresentationProof(prepared: PreparedGrantBody, opening: RegistryDisclosure, source: SealSource): Operation<PreparedGrantBody>;
+    /** Authenticate and authorize the selected graph before the Grant builder and after receipt waits. */
+    prepareGrant(sender: string, selection: DisclosureSelection, options: IpexV2BodyOptions & {
+        priorSaid?: string;
+        presentation?: AcdcV2Registry;
+        auths?: WitnessAuthMap;
+    }): Operation<PreparedDisclosure>;
+    /** Carry selected public evidence and root-first delegation ancestry; receiver intake still verifies every approval. */
+    proofSupport(raw: Uint8Array, hab: Hab): Uint8Array;
+    /** Public replay includes actual stored witness receipts; it grants no new consent. */
+    kel(hab: Hab): Uint8Array;
+}
+//# sourceMappingURL=disclosing.d.ts.map

package/types/src/disclosing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disclosing.d.ts","sourceRoot":"","sources":["../../src/src/disclosing.ts"],"names":[],"mappings":"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"}