signify-ts 0.2.1 → 0.3.0-dev.e31e78d

package/dist/keri/core/keeping.js

@@ -0,0 +1,347 @@
+import { Algos, SaltyCreator, RandyCreator } from "./manager.js";
+import { MtrDex } from "./matter.js";
+import { Tier } from "./salter.js";
+import { Encrypter } from "../core/encrypter.js";
+import { Decrypter } from "./decrypter.js";
+import { b } from "./core.js";
+import { Cipher } from "./cipher.js";
+import { Diger } from "./diger.js";
+import { Prefixer } from "./prefixer.js";
+/**
+ * Creates IdentifierManager instances based on the algorithm and key indexes.
+ */
+export class IdentifierManagerFactory {
+    /**
+     * Creates a factory for generating IdentifierManagers. Requires a salt to be specified.
+     * Allows external key management modules to be configured.
+     * @param salter
+     * @param externalModules
+     */
+    constructor(salter, externalModules = []) {
+        this.salter = salter;
+        this.modules = {};
+        this.salter = salter;
+        for (const mod of externalModules) {
+            this.modules[mod.type] = mod.module;
+        }
+    }
+    /**
+     *
+     * @param algo
+     * @param pidx
+     * @param kargs
+     */
+    new(algo, pidx, kargs) {
+        switch (algo) {
+            case Algos.salty:
+                return new SaltyIdentifierManager(this.salter, pidx, kargs['kidx'], kargs['tier'], kargs['transferable'], kargs['stem'], kargs['code'], kargs['count'], kargs['icodes'], kargs['ncode'], kargs['ncount'], kargs['ncodes'], kargs['dcode'], kargs['bran'], kargs['sxlt']);
+            case Algos.randy:
+                return new RandyIdentifierManager(this.salter, kargs['code'], kargs['count'], kargs['icodes'], kargs['transferable'], kargs['ncode'], kargs['ncount'], kargs['ncodes'], kargs['dcode'], kargs['prxs'], kargs['nxts']);
+            case Algos.group:
+                return new GroupIdentifierManager(this, kargs['mhab'], kargs['states'], kargs['rstates'], kargs['keys'], kargs['ndigs']);
+            case Algos.extern: {
+                const ModuleConstructor = this.modules[kargs.extern_type];
+                if (!ModuleConstructor) {
+                    throw new Error(`unsupported external module type ${kargs.extern_type}`);
+                }
+                return new ModuleConstructor(pidx, kargs);
+            }
+            default:
+                throw new Error('Unknown algo');
+        }
+    }
+    /**
+     * Generates an algorithm-specific IdentifierManager instance with correct keys based on
+     * the indexes provided by the HabState.
+     * @param aid HabState with the algorithm and key indexes
+     * @returns IdentifierManager instance
+     */
+    get(aid) {
+        if (Algos.salty in aid) {
+            return new SaltyIdentifierManager(this.salter, aid.salty.pidx, aid.salty.kidx, aid.salty.tier, aid.salty.transferable, aid.salty.stem, undefined, undefined, aid.salty.icodes, undefined, undefined, aid.salty.ncodes, aid.salty.dcode, undefined, aid.salty.sxlt);
+        }
+        else if (Algos.randy in aid) {
+            return new RandyIdentifierManager(this.salter, undefined, undefined, undefined, new Prefixer({ qb64: aid['prefix'] }).transferable, undefined, undefined, [], undefined, aid.randy.prxs, aid.randy.nxts);
+        }
+        else if (Algos.group in aid) {
+            return new GroupIdentifierManager(this, aid.group.mhab, undefined, undefined, aid.group.keys, aid.group.ndigs);
+        }
+        else if (Algos.extern in aid) {
+            const typ = aid.extern.extern_type;
+            if (typ in this.modules) {
+                const mod = new this.modules[typ](aid.extern.pidx, aid.extern);
+                return mod;
+            }
+            else {
+                throw new Error(`unsupported external module type ${typ}`);
+            }
+        }
+        else {
+            throw new Error('No algo specified');
+        }
+    }
+}
+export class SaltyIdentifierManager {
+    constructor(salter, pidx, kidx = 0, tier = Tier.low, transferable = false, stem = undefined, code = MtrDex.Ed25519_Seed, count = 1, icodes = undefined, ncode = MtrDex.Ed25519_Seed, ncount = 1, ncodes = undefined, dcode = MtrDex.Blake3_256, bran = undefined, sxlt = undefined) {
+        this.algo = Algos.salty;
+        // # Salter is the entered passcode and used for enc/dec of salts for each AID
+        this.salter = salter;
+        const signer = this.salter.signer(code, transferable, undefined, tier);
+        this.aeid = signer.verfer.qb64;
+        this.encrypter = new Encrypter({}, b(this.aeid));
+        this.decrypter = new Decrypter({}, signer.qb64b);
+        this.code = code;
+        this.ncode = ncode;
+        this.tier = tier;
+        this.icodes =
+            icodes == undefined ? new Array(count).fill(code) : icodes;
+        this.ncodes =
+            ncodes == undefined
+                ? new Array(ncount).fill(ncode)
+                : ncodes;
+        this.dcode = dcode;
+        this.pidx = pidx;
+        this.kidx = kidx;
+        this.transferable = transferable;
+        this.count = count;
+        this.ncount = ncount;
+        this.stem = stem == undefined ? 'signify:aid' : stem;
+        if (bran != undefined) {
+            this.bran = MtrDex.Salt_128 + 'A' + bran.slice(0, 21);
+            this.creator = new SaltyCreator(this.bran, this.tier, this.stem);
+            this.sxlt = this.encrypter.encrypt(b(this.creator.salt)).qb64;
+        }
+        else if (sxlt == undefined) {
+            this.creator = new SaltyCreator(undefined, this.tier, this.stem);
+            this.sxlt = this.encrypter.encrypt(b(this.creator.salt)).qb64;
+        }
+        else {
+            this.sxlt = sxlt;
+            const ciph = new Cipher({ qb64: this.sxlt });
+            this.creator = new SaltyCreator(this.decrypter.decrypt(null, ciph).qb64, tier, this.stem);
+        }
+        this.signers = this.creator.create(this.icodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, this.kidx, false).signers;
+    }
+    params() {
+        return {
+            sxlt: this.sxlt,
+            pidx: this.pidx,
+            kidx: this.kidx,
+            stem: this.stem,
+            tier: this.tier,
+            icodes: this.icodes,
+            ncodes: this.ncodes,
+            dcode: this.dcode,
+            transferable: this.transferable,
+        };
+    }
+    async incept(transferable) {
+        var _a;
+        this.transferable = transferable;
+        this.kidx = 0;
+        const signers = this.creator.create(this.icodes, this.count, this.code, this.transferable, this.pidx, 0, this.kidx, false);
+        const verfers = signers.signers.map((signer) => signer.verfer.qb64);
+        const nsigners = this.creator.create(this.ncodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, (_a = this.icodes) === null || _a === void 0 ? void 0 : _a.length, false);
+        const digers = nsigners.signers.map((nsigner) => new Diger({ code: this.dcode }, nsigner.verfer.qb64b).qb64);
+        return [verfers, digers];
+    }
+    async rotate(ncodes, transferable) {
+        this.ncodes = ncodes;
+        this.transferable = transferable;
+        const signers = this.creator.create(this.ncodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, this.kidx + this.icodes.length, false);
+        const verfers = signers.signers.map((signer) => signer.verfer.qb64);
+        this.kidx = this.kidx + this.icodes.length;
+        const nsigners = this.creator.create(this.ncodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, this.kidx + this.icodes.length, false);
+        const digers = nsigners.signers.map((nsigner) => new Diger({ code: this.dcode }, nsigner.verfer.qb64b).qb64);
+        return [verfers, digers];
+    }
+    async sign(ser, indexed = true, indices = undefined, ondices = undefined) {
+        const signers = this.creator.create(this.icodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, this.kidx, false);
+        if (indexed) {
+            const sigers = [];
+            let i = 0;
+            for (const [j, signer] of signers.signers.entries()) {
+                if (indices != undefined) {
+                    i = indices[j];
+                    if (typeof i != 'number' || i < 0) {
+                        throw new Error(`Invalid signing index = ${i}, not whole number.`);
+                    }
+                }
+                else {
+                    i = j;
+                }
+                let o = 0;
+                if (ondices != undefined) {
+                    o = ondices[j];
+                    if ((o == undefined ||
+                        (typeof o == 'number' &&
+                            typeof o != 'number' &&
+                            o >= 0))) {
+                        throw new Error(`Invalid ondex = ${o}, not whole number.`);
+                    }
+                }
+                else {
+                    o = i;
+                }
+                sigers.push(signer.sign(ser, i, o == undefined ? true : false, o));
+            }
+            return sigers.map((siger) => siger.qb64);
+        }
+        else {
+            const cigars = [];
+            for (const [, signer] of signers.signers.entries()) {
+                cigars.push(signer.sign(ser));
+            }
+            return cigars.map((cigar) => cigar.qb64);
+        }
+    }
+}
+export class RandyIdentifierManager {
+    constructor(salter, code = MtrDex.Ed25519_Seed, count = 1, icodes = undefined, transferable = false, ncode = MtrDex.Ed25519_Seed, ncount = 1, ncodes, dcode = MtrDex.Blake3_256, prxs = undefined, nxts = undefined) {
+        this.algo = Algos.randy;
+        this.salter = salter;
+        this.icodes =
+            icodes == undefined ? new Array(count).fill(code) : icodes;
+        this.ncodes =
+            ncodes == undefined
+                ? new Array(ncount).fill(ncode)
+                : ncodes;
+        this.code = code;
+        this.ncode = ncode;
+        this.count = count;
+        this.ncount = ncount;
+        const signer = this.salter.signer(code, transferable);
+        this.aeid = signer.verfer.qb64;
+        this.encrypter = new Encrypter({}, b(this.aeid));
+        this.decrypter = new Decrypter({}, signer.qb64b);
+        this.nxts = nxts !== null && nxts !== void 0 ? nxts : [];
+        this.prxs = prxs !== null && prxs !== void 0 ? prxs : [];
+        this.transferable = transferable;
+        this.icodes = icodes;
+        this.ncodes = ncodes;
+        this.dcode = dcode;
+        this.creator = new RandyCreator();
+        this.signers = this.prxs.map((prx) => this.decrypter.decrypt(new Cipher({ qb64: prx }).qb64b, undefined, this.transferable));
+    }
+    params() {
+        return {
+            nxts: this.nxts,
+            prxs: this.prxs,
+            transferable: this.transferable,
+        };
+    }
+    async incept(transferable) {
+        this.transferable = transferable;
+        const signers = this.creator.create(this.icodes, this.count, this.code, this.transferable);
+        this.prxs = signers.signers.map((signer) => this.encrypter.encrypt(undefined, signer).qb64);
+        const verfers = signers.signers.map((signer) => signer.verfer.qb64);
+        const nsigners = this.creator.create(this.ncodes, this.ncount, this.ncode, this.transferable);
+        this.nxts = nsigners.signers.map((signer) => this.encrypter.encrypt(undefined, signer).qb64);
+        const digers = nsigners.signers.map((nsigner) => new Diger({ code: this.dcode }, nsigner.verfer.qb64b).qb64);
+        return [verfers, digers];
+    }
+    async rotate(ncodes, transferable) {
+        this.ncodes = ncodes;
+        this.transferable = transferable;
+        this.prxs = this.nxts;
+        const signers = this.nxts.map((nxt) => this.decrypter.decrypt(undefined, new Cipher({ qb64: nxt }), this.transferable));
+        const verfers = signers.map((signer) => signer.verfer.qb64);
+        const nsigners = this.creator.create(this.ncodes, this.ncount, this.ncode, this.transferable);
+        this.nxts = nsigners.signers.map((signer) => this.encrypter.encrypt(undefined, signer).qb64);
+        const digers = nsigners.signers.map((nsigner) => new Diger({ code: this.dcode }, nsigner.verfer.qb64b).qb64);
+        return [verfers, digers];
+    }
+    async sign(ser, indexed = true, indices = undefined, ondices = undefined) {
+        const signers = this.prxs.map((prx) => this.decrypter.decrypt(new Cipher({ qb64: prx }).qb64b, undefined, this.transferable));
+        if (indexed) {
+            const sigers = [];
+            let i = 0;
+            for (const [j, signer] of signers.entries()) {
+                if (indices != undefined) {
+                    i = indices[j];
+                    if (typeof i != 'number' || i < 0) {
+                        throw new Error(`Invalid signing index = ${i}, not whole number.`);
+                    }
+                }
+                else {
+                    i = j;
+                }
+                let o = 0;
+                if (ondices != undefined) {
+                    o = ondices[j];
+                    if ((o == undefined ||
+                        (typeof o == 'number' &&
+                            typeof o != 'number' &&
+                            o >= 0))) {
+                        throw new Error(`Invalid ondex = ${o}, not whole number.`);
+                    }
+                }
+                else {
+                    o = i;
+                }
+                sigers.push(signer.sign(ser, i, o == undefined ? true : false, o));
+            }
+            return sigers.map((siger) => siger.qb64);
+        }
+        else {
+            const cigars = [];
+            for (const [, signer] of signers.entries()) {
+                cigars.push(signer.sign(ser));
+            }
+            return cigars.map((cigar) => cigar.qb64);
+        }
+    }
+}
+export class GroupIdentifierManager {
+    constructor(manager, mhab, states = undefined, rstates = undefined, keys = [], ndigs = []) {
+        var _a, _b;
+        this.gkeys = [];
+        this.gdigs = [];
+        this.algo = Algos.group;
+        this.manager = manager;
+        if (states != undefined) {
+            keys = states.map((state) => state['k'][0]);
+        }
+        if (rstates != undefined) {
+            ndigs = rstates.map((state) => state['n'][0]);
+        }
+        this.gkeys = (_a = states === null || states === void 0 ? void 0 : states.map((state) => state['k'][0])) !== null && _a !== void 0 ? _a : keys;
+        this.gdigs = (_b = rstates === null || rstates === void 0 ? void 0 : rstates.map((state) => state['n'][0])) !== null && _b !== void 0 ? _b : ndigs;
+        this.mhab = mhab;
+        this.signers = [];
+    }
+    async incept() {
+        return [this.gkeys, this.gdigs];
+    }
+    /**
+     * Performs a multisig rotation
+     * @param _ncodes
+     * @param _transferable
+     * @param states
+     * @param rstates key state records for the prior establishment event indicating next key digests.
+     *                You should pass in the current key
+     */
+    async rotate(_ncodes, _transferable, states, rstates) {
+        this.gkeys = states.map((state) => state['k'][0]);
+        this.gdigs = rstates.map((state) => state['n'][0]);
+        return [this.gkeys, this.gdigs];
+    }
+    async sign(ser, indexed = true) {
+        if (!this.mhab.state) {
+            throw new Error(`No state in mhab`);
+        }
+        const key = this.mhab['state']['k'][0];
+        const ndig = this.mhab['state']['n'][0];
+        const csi = this.gkeys.indexOf(key); // csi = current signing index (from current rotation event)
+        const pni = this.gdigs.indexOf(ndig); // pni = prior next index (from last establishment event)
+        const mkeeper = this.manager.get(this.mhab);
+        return await mkeeper.sign(ser, indexed, [csi], [pni]);
+    }
+    params() {
+        return {
+            mhab: this.mhab,
+            keys: this.gkeys,
+            ndigs: this.gdigs,
+        };
+    }
+}

package/{src/keri/core/kering.ts → dist/keri/core/kering.js}

@@ -1,9 +1,7 @@
 export class EmptyMaterialError {
-    private readonly _err: Error;
-    constructor(err: string) {
+    constructor(err) {
         this._err = new Error(err);
     }
-
     get err() {
         return this._err;
     }

package/dist/keri/core/keyState.d.ts

@@ -0,0 +1,98 @@
+import { components } from '../../types/keria-api-schema.ts';
+export type KeyState = components['schemas']['KeyStateRecord'];
+export type EstablishmentState = components['schemas']['StateEERecord'];
+/**
+ * Marker interface for state configuring an IdentifierManager.
+ */
+export interface IdentifierManagerState {
+}
+/**
+ * Defining configuration parameters for a specified, deterministic salt of an IdentifierManager.
+ */
+export type SaltyKeyState = components['schemas']['SaltyState'];
+/**
+ * Defining configuration parameters for a random seed identifier manager.
+ */
+export type RandyKeyState = components['schemas']['RandyKeyState'];
+/**
+ * Defining properties a multi-signature group identifier manager.
+ */
+export type GroupKeyState = components['schemas']['GroupKeyState'];
+/**
+ * Defining properties for an external module identifier manager that uses externally managed keys such as in an HSM or a KMS system.
+ */
+export type ExternState = components['schemas']['ExternState'];
+/**
+ * Defining properties of an identifier habitat, know as a Hab in KERIpy.
+ */
+export type HabState = components['schemas']['HabState'];
+export type Icp = components['schemas']['ICP_V_1'] | components['schemas']['ICP_V_2'];
+export type Ixn = components['schemas']['IXN_V_1'] | components['schemas']['IXN_V_2'];
+export type ExnV1 = components['schemas']['EXN_V_1'];
+export type Dip = components['schemas']['DIP_V_1'] | components['schemas']['DIP_V_2'];
+export type Rot = components['schemas']['ROT_V_1'] | components['schemas']['ROT_V_2'];
+export type ExnEmbeds = components['schemas']['ExnEmbeds'];
+export type MultisigRpyEmbeds = components['schemas']['MultisigRpyEmbeds'];
+/**
+ * Defining Operation types
+ */
+export type OOBIOperation = components['schemas']['OOBIOperation'];
+export type QueryOperation = components['schemas']['QueryOperation'];
+export type EndRoleOperation = components['schemas']['EndRoleOperation'];
+export type WitnessOperation = components['schemas']['WitnessOperation'];
+export type DelegationOperation = components['schemas']['DelegationOperation'];
+export type RegistryOperation = components['schemas']['RegistryOperation'];
+export type LocSchemeOperation = components['schemas']['LocSchemeOperation'];
+export type ChallengeOperation = components['schemas']['ChallengeOperation'];
+export type ExchangeOperation = components['schemas']['ExchangeOperation'];
+export type SubmitOperation = components['schemas']['SubmitOperation'];
+export type DoneOperation = components['schemas']['DoneOperation'];
+export type CredentialOperation = components['schemas']['CredentialOperation'];
+export type GroupOperation = components['schemas']['GroupOperation'];
+export type DelegatorOperation = components['schemas']['DelegatorOperation'];
+export type PendingOOBIOperation = components['schemas']['PendingOOBIOperation'];
+export type PendingQueryOperation = components['schemas']['PendingQueryOperation'];
+export type PendingEndRoleOperation = components['schemas']['PendingEndRoleOperation'];
+export type PendingWitnessOperation = components['schemas']['PendingWitnessOperation'];
+export type PendingDelegationOperation = components['schemas']['PendingDelegationOperation'];
+export type PendingRegistryOperation = components['schemas']['PendingRegistryOperation'];
+export type PendingLocSchemeOperation = components['schemas']['PendingLocSchemeOperation'];
+export type PendingChallengeOperation = components['schemas']['PendingChallengeOperation'];
+export type PendingExchangeOperation = components['schemas']['PendingExchangeOperation'];
+export type PendingSubmitOperation = components['schemas']['PendingSubmitOperation'];
+export type PendingDoneOperation = components['schemas']['PendingDoneOperation'];
+export type PendingCredentialOperation = components['schemas']['PendingCredentialOperation'];
+export type PendingGroupOperation = components['schemas']['PendingGroupOperation'];
+export type PendingDelegatorOperation = components['schemas']['PendingDelegatorOperation'];
+export type PendingOperation = PendingOOBIOperation | PendingQueryOperation | PendingEndRoleOperation | PendingWitnessOperation | PendingDelegationOperation | PendingRegistryOperation | PendingLocSchemeOperation | PendingChallengeOperation | PendingExchangeOperation | PendingSubmitOperation | PendingDoneOperation | PendingCredentialOperation | PendingGroupOperation | PendingDelegatorOperation;
+export type CompletedWitnessOperation = components['schemas']['CompletedWitnessOperation'];
+export type CompletedEndRoleOperation = components['schemas']['CompletedEndRoleOperation'];
+export type CompletedOOBIOperation = components['schemas']['CompletedOOBIOperation'];
+export type CompletedDelegationOperation = components['schemas']['CompletedDelegationOperation'];
+export type CompletedRegistryOperation = components['schemas']['CompletedRegistryOperation'];
+export type CompletedLocSchemeOperation = components['schemas']['CompletedLocSchemeOperation'];
+export type CompletedChallengeOperation = components['schemas']['CompletedChallengeOperation'];
+export type CompletedExchangeOperation = components['schemas']['CompletedExchangeOperation'];
+export type CompletedSubmitOperation = components['schemas']['CompletedSubmitOperation'];
+export type CompletedDoneOperation = components['schemas']['CompletedDoneOperation'];
+export type CompletedCredentialOperation = components['schemas']['CompletedCredentialOperation'];
+export type CompletedGroupOperation = components['schemas']['CompletedGroupOperation'];
+export type CompletedDelegatorOperation = components['schemas']['CompletedDelegatorOperation'];
+export type CompletedQueryOperation = components['schemas']['CompletedQueryOperation'];
+export type CompletedOperation = CompletedOOBIOperation | CompletedEndRoleOperation | CompletedWitnessOperation | CompletedDelegationOperation | CompletedRegistryOperation | CompletedLocSchemeOperation | CompletedChallengeOperation | CompletedExchangeOperation | CompletedSubmitOperation | CompletedDoneOperation | CompletedCredentialOperation | CompletedGroupOperation | CompletedDelegatorOperation | CompletedQueryOperation;
+export type FailedOOBIOperation = components['schemas']['FailedOOBIOperation'];
+export type FailedQueryOperation = components['schemas']['FailedQueryOperation'];
+export type FailedEndRoleOperation = components['schemas']['FailedEndRoleOperation'];
+export type FailedWitnessOperation = components['schemas']['FailedWitnessOperation'];
+export type FailedDelegationOperation = components['schemas']['FailedDelegationOperation'];
+export type FailedRegistryOperation = components['schemas']['FailedRegistryOperation'];
+export type FailedLocSchemeOperation = components['schemas']['FailedLocSchemeOperation'];
+export type FailedChallengeOperation = components['schemas']['FailedChallengeOperation'];
+export type FailedExchangeOperation = components['schemas']['FailedExchangeOperation'];
+export type FailedSubmitOperation = components['schemas']['FailedSubmitOperation'];
+export type FailedDoneOperation = components['schemas']['FailedDoneOperation'];
+export type FailedCredentialOperation = components['schemas']['FailedCredentialOperation'];
+export type FailedGroupOperation = components['schemas']['FailedGroupOperation'];
+export type FailedDelegatorOperation = components['schemas']['FailedDelegatorOperation'];
+export type FailedOperation = FailedOOBIOperation | FailedQueryOperation | FailedEndRoleOperation | FailedWitnessOperation | FailedDelegationOperation | FailedRegistryOperation | FailedLocSchemeOperation | FailedChallengeOperation | FailedExchangeOperation | FailedSubmitOperation | FailedDoneOperation | FailedCredentialOperation | FailedGroupOperation | FailedDelegatorOperation;
+export type GenericOperation = OOBIOperation | QueryOperation | EndRoleOperation | WitnessOperation | DelegationOperation | RegistryOperation | LocSchemeOperation | ChallengeOperation | ExchangeOperation | SubmitOperation | DoneOperation | CredentialOperation | GroupOperation | DelegatorOperation;