signify-ts 0.3.0-rc2 → 0.4.0

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

@@ -46,7 +46,18 @@ export interface IdentifierManager<T extends IdentifierManagerParams = Identifie
     params(): T;
     incept(transferable: boolean): Promise<IdentifierManagerResult>;
     rotate(ncodes: string[], transferable: boolean, states?: KeyState[], rstates?: KeyState[]): Promise<IdentifierManagerResult>;
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[], ondices?: number[]): Promise<SignResult>;
+    /**
+     * Sign serialized bytes.
+     *
+     * `rotated` is meaningful for group identifiers only. Callers building a
+     * group rotation must pass `rotated=true` so the group signature exposes
+     * prior-next `ondex`; non-rotation calls leave it false/current-only.
+     *
+     * `ondices === undefined` uses the default dual-index behavior where each
+     * `ondex` matches its `index`. `ondices[j] === undefined` is the explicit
+     * current-only case for that signature, so no `ondex` is emitted.
+     */
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[], ondices?: Array<number | undefined>, rotated?: boolean): Promise<SignResult>;
 }
 /**
  * Creates IdentifierManager instances based on the algorithm and key indexes.
@@ -102,7 +113,7 @@ export declare class SaltyIdentifierManager implements IdentifierManager {
     params(): SaltyManagerParams;
     incept(transferable: boolean): Promise<IdentifierManagerResult>;
     rotate(ncodes: string[], transferable: boolean): Promise<[string[], string[]]>;
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Array<number | undefined> | undefined, _rotated?: boolean): Promise<SignResult>;
 }
 export declare class RandyIdentifierManager implements IdentifierManager {
     private salter;
@@ -126,29 +137,121 @@ export declare class RandyIdentifierManager implements IdentifierManager {
     params(): RandyManagerParams;
     incept(transferable: boolean): Promise<IdentifierManagerResult>;
     rotate(ncodes: string[], transferable: boolean): Promise<IdentifierManagerResult>;
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Array<number | undefined> | undefined, _rotated?: boolean): Promise<SignResult>;
 }
+/**
+ * Identifier manager for group identifiers.
+ *
+ * A group identifier does not have its own private signing keys. Instead, this
+ * manager maps group event signing indexes onto the local member AID (`mhab`)
+ * and delegates actual signing to that member's key manager.
+ *
+ * The central invariant is that indexed rotation signatures carry two
+ * positions:
+ *
+ * - `index` points to the signer's current key in the event's current key list
+ *   (`k`), which SignifyTS derives from `states`.
+ * - `ondex` points to the prior establishment event's next digest list (`n`),
+ *   proving that the current key was a precommitted key.
+ *
+ * `rstates` are the proposed next digest source for the new event. They are not
+ * the signer authorization set for the event being signed.
+ */
 export declare class GroupIdentifierManager implements IdentifierManager {
+    /** Factory used to recover the local member keeper that performs signing. */
     private manager;
+    /** Local member AID whose private key signs on behalf of the group. */
     private mhab;
+    /**
+     * Current group signing public keys for the event being built. During
+     * rotation these come from `states[*].k[0]` and define signature `index`.
+     */
     private gkeys;
+    /**
+     * Proposed next digest list for the event being built. During rotation
+     * these come from `rstates[*].n[0]`, are returned from `rotate()`, and are
+     * serialized as `group.ndigs`.
+     */
     private gdigs;
+    /**
+     * Prior next digest list from the current group establishment event. For
+     * rotations, this is the authorization commitment set used to derive
+     * `ondex`; it must remain separate from proposed next digests in `gdigs`.
+     */
+    private gpndigs;
     algo: Algos;
+    /**
+     * Retained for the `IdentifierManager` interface. Group signing delegates
+     * to the local member AID keeper instead of storing signers here.
+     */
     signers: Signer[];
+    /**
+     * Creates a manager for either a new group event or an existing group AID.
+     *
+     * `states` and `rstates` are app-level key state records used when creating
+     * a new group event. `keys` and `ndigs` are persisted group manager params
+     * used when loading an existing group. For an existing group, `ndigs` is
+     * expected to be the current establishment event's next digest list.
+     *
+     * During group inception there is no separate prior establishment event, so
+     * `gpndigs` starts as the same digest list as `gdigs`. During rotation,
+     * `gdigs` changes to the proposed next digests, while `gpndigs` stays
+     * fixed for `ondex` derivation.
+     */
     constructor(manager: IdentifierManagerFactory, mhab: HabState, states?: KeyState[] | undefined, rstates?: KeyState[] | undefined, keys?: string[], ndigs?: string[]);
+    /**
+     * Returns the inception key material for the group event.
+     *
+     * Inception has no prior group establishment event. The current keys and
+     * proposed next digests are therefore returned directly from the manager's
+     * configured `states` and `rstates`.
+     */
     incept(): Promise<IdentifierManagerResult>;
     /**
-     * Performs a multisig rotation
+     * Performs a multisig rotation.
+     *
+     * `states` supplies the current group signing keys for the event being
+     * signed. `rstates` supplies the proposed next key digests to put in the
+     * new event. The prior next digests used for rotation `ondex` lookup stay
+     * unchanged until KERIA accepts the new establishment event and returns an
+     * updated group state.
+     *
      * @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
+     * @param rstates
      */
     rotate(_ncodes: string[], _transferable: boolean, states: KeyState[], rstates: KeyState[]): Promise<IdentifierManagerResult>;
-    sign(ser: Uint8Array, indexed?: boolean): Promise<SignResult>;
+    /**
+     * Signs for the group by delegating to the local member keeper.
+     */
+    sign(ser: Uint8Array, indexed?: boolean, _indices?: number[] | undefined, _ondices?: Array<number | undefined> | undefined, rotated?: boolean): Promise<SignResult>;
+    /**
+     * Finds the prior next digest position that precommitted the current key.
+     *
+     * This mirrors KERIpy's exposed-prior-next behavior: for each prior next
+     * digest, hash the current verifier key using that digest's code and compare
+     * the result to the digest at that position. A match means the signer has
+     * exposed that precommitted key, and the matching position is the `ondex`.
+     */
+    private priorNextIndexForKey;
     params(): {
-        mhab: HabState;
+        mhab: {
+            name: string;
+            prefix: string;
+            icp_dt: string;
+            state: import("../../types/keria-api-schema.ts").components["schemas"]["KeyStateRecord"];
+            transferable: boolean;
+            windexes: string[];
+        } & ({
+            salty: import("../../types/keria-api-schema.ts").components["schemas"]["SaltyState"];
+        } | {
+            randy: import("../../types/keria-api-schema.ts").components["schemas"]["RandyKeyState"];
+        } | {
+            group: import("../../types/keria-api-schema.ts").components["schemas"]["GroupKeyState"];
+        } | {
+            extern: import("../../types/keria-api-schema.ts").components["schemas"]["ExternState"];
+        });
         keys: string[];
         ndigs: string[];
     };

package/dist/keri/core/keeping.js

@@ -7,6 +7,7 @@ import { b } from "./core.js";
 import { Cipher } from "./cipher.js";
 import { Diger } from "./diger.js";
 import { Prefixer } from "./prefixer.js";
+import { Verfer } from "./verfer.js";
 /**
  * Creates IdentifierManager instances based on the algorithm and key indexes.
  */
@@ -57,45 +58,27 @@ export class IdentifierManagerFactory {
      * @returns IdentifierManager instance
      */
     get(aid) {
-        const algo = aid[Algos.salty]
-            ? Algos.salty
-            : aid[Algos.randy]
-                ? Algos.randy
-                : aid[Algos.group]
-                    ? Algos.group
-                    : aid[Algos.extern]
-                        ? Algos.extern
-                        : undefined;
-        if (!algo) {
-            throw new Error('No algo specified');
+        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);
         }
-        let kargs = aid[algo];
-        if (!kargs) {
-            throw new Error('No kargs found in HabState');
+        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);
         }
-        switch (algo) {
-            case Algos.salty:
-                kargs = kargs;
-                return new SaltyIdentifierManager(this.salter, kargs.pidx, kargs.kidx, kargs.tier, kargs.transferable, kargs.stem, undefined, undefined, kargs.icodes, undefined, undefined, kargs.ncodes, kargs.dcode, undefined, kargs.sxlt);
-            case Algos.randy:
-                kargs = kargs;
-                return new RandyIdentifierManager(this.salter, undefined, undefined, undefined, new Prefixer({ qb64: aid['prefix'] }).transferable, undefined, undefined, [], undefined, kargs.prxs, kargs.nxts);
-            case Algos.group:
-                kargs = kargs;
-                return new GroupIdentifierManager(this, kargs.mhab, undefined, undefined, kargs.keys, kargs.ndigs);
-            case Algos.extern: {
-                kargs = kargs;
-                const typ = kargs.extern_type;
-                if (typ in this.modules) {
-                    const mod = new this.modules[typ](kargs.pidx, kargs);
-                    return mod;
-                }
-                else {
-                    throw new Error(`unsupported external module type ${typ}`);
-                }
+        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;
             }
-            default:
-                throw new Error('Algo not allowed yet');
+            else {
+                throw new Error(`unsupported external module type ${typ}`);
+            }
+        }
+        else {
+            throw new Error('No algo specified');
         }
     }
 }
@@ -173,7 +156,7 @@ export class SaltyIdentifierManager {
         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) {
+    async sign(ser, indexed = true, indices = undefined, ondices = undefined, _rotated) {
         const signers = this.creator.create(this.icodes, this.ncount, this.ncode, this.transferable, this.pidx, 0, this.kidx, false);
         if (indexed) {
             const sigers = [];
@@ -191,17 +174,14 @@ export class SaltyIdentifierManager {
                 let o = 0;
                 if (ondices != undefined) {
                     o = ondices[j];
-                    if ((o == undefined ||
-                        (typeof o == 'number' &&
-                            typeof o != 'number' &&
-                            o >= 0))) {
+                    if (o !== undefined && (!Number.isInteger(o) || 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));
+                sigers.push(signer.sign(ser, i, o === undefined ? true : false, o));
             }
             return sigers.map((siger) => siger.qb64);
         }
@@ -269,7 +249,7 @@ export class RandyIdentifierManager {
         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) {
+    async sign(ser, indexed = true, indices = undefined, ondices = undefined, _rotated) {
         const signers = this.prxs.map((prx) => this.decrypter.decrypt(new Cipher({ qb64: prx }).qb64b, undefined, this.transferable));
         if (indexed) {
             const sigers = [];
@@ -287,17 +267,14 @@ export class RandyIdentifierManager {
                 let o = 0;
                 if (ondices != undefined) {
                     o = ondices[j];
-                    if ((o == undefined ||
-                        (typeof o == 'number' &&
-                            typeof o != 'number' &&
-                            o >= 0))) {
+                    if (o !== undefined && (!Number.isInteger(o) || 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));
+                sigers.push(signer.sign(ser, i, o === undefined ? true : false, o));
             }
             return sigers.map((siger) => siger.qb64);
         }
@@ -310,11 +287,57 @@ export class RandyIdentifierManager {
         }
     }
 }
+/**
+ * Identifier manager for group identifiers.
+ *
+ * A group identifier does not have its own private signing keys. Instead, this
+ * manager maps group event signing indexes onto the local member AID (`mhab`)
+ * and delegates actual signing to that member's key manager.
+ *
+ * The central invariant is that indexed rotation signatures carry two
+ * positions:
+ *
+ * - `index` points to the signer's current key in the event's current key list
+ *   (`k`), which SignifyTS derives from `states`.
+ * - `ondex` points to the prior establishment event's next digest list (`n`),
+ *   proving that the current key was a precommitted key.
+ *
+ * `rstates` are the proposed next digest source for the new event. They are not
+ * the signer authorization set for the event being signed.
+ */
 export class GroupIdentifierManager {
+    /**
+     * Creates a manager for either a new group event or an existing group AID.
+     *
+     * `states` and `rstates` are app-level key state records used when creating
+     * a new group event. `keys` and `ndigs` are persisted group manager params
+     * used when loading an existing group. For an existing group, `ndigs` is
+     * expected to be the current establishment event's next digest list.
+     *
+     * During group inception there is no separate prior establishment event, so
+     * `gpndigs` starts as the same digest list as `gdigs`. During rotation,
+     * `gdigs` changes to the proposed next digests, while `gpndigs` stays
+     * fixed for `ondex` derivation.
+     */
     constructor(manager, mhab, states = undefined, rstates = undefined, keys = [], ndigs = []) {
         var _a, _b;
+        /**
+         * Current group signing public keys for the event being built. During
+         * rotation these come from `states[*].k[0]` and define signature `index`.
+         */
         this.gkeys = [];
+        /**
+         * Proposed next digest list for the event being built. During rotation
+         * these come from `rstates[*].n[0]`, are returned from `rotate()`, and are
+         * serialized as `group.ndigs`.
+         */
         this.gdigs = [];
+        /**
+         * Prior next digest list from the current group establishment event. For
+         * rotations, this is the authorization commitment set used to derive
+         * `ondex`; it must remain separate from proposed next digests in `gdigs`.
+         */
+        this.gpndigs = [];
         this.algo = Algos.group;
         this.manager = manager;
         if (states != undefined) {
@@ -325,36 +348,92 @@ export class GroupIdentifierManager {
         }
         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.gpndigs = this.gdigs;
         this.mhab = mhab;
         this.signers = [];
     }
+    /**
+     * Returns the inception key material for the group event.
+     *
+     * Inception has no prior group establishment event. The current keys and
+     * proposed next digests are therefore returned directly from the manager's
+     * configured `states` and `rstates`.
+     */
     async incept() {
         return [this.gkeys, this.gdigs];
     }
     /**
-     * Performs a multisig rotation
+     * Performs a multisig rotation.
+     *
+     * `states` supplies the current group signing keys for the event being
+     * signed. `rstates` supplies the proposed next key digests to put in the
+     * new event. The prior next digests used for rotation `ondex` lookup stay
+     * unchanged until KERIA accepts the new establishment event and returns an
+     * updated group state.
+     *
      * @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
+     * @param rstates
      */
     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) {
+    /**
+     * Signs for the group by delegating to the local member keeper.
+     */
+    async sign(ser, indexed = true, _indices = undefined, _ondices = undefined, rotated = false) {
         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];
+        // The event's current key list authorizes the signature's `index`.
         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)
+        if (csi < 0) {
+            throw new Error(`Group signing key ${key} is not present in current group signing keys.`);
+        }
+        let pni; // prior next index exposed as signature `ondex`
+        if (rotated) {
+            // Rotation call sites must explicitly request prior-next exposure,
+            // dual indexed signatures with both an index (csi) and an ondex (pni)
+            pni = this.priorNextIndexForKey(key);
+        }
+        else {
+            // Inception and non-rotation signatures satisfy only the current
+            // signing threshold. The event's `n` field is a precommitment for a
+            // future rotation, not an `ondex` source.
+            pni = undefined;
+        }
+        if (pni !== undefined && pni < 0) {
+            throw new Error(`Group signing key ${key} cannot derive ondex from prior next digest list.`);
+        }
+        // Delegate the actual signature to the local member AID keeper while
+        // supplying group-level index and ondex positions.
         const mkeeper = this.manager.get(this.mhab);
         return await mkeeper.sign(ser, indexed, [csi], [pni]);
     }
+    /**
+     * Finds the prior next digest position that precommitted the current key.
+     *
+     * This mirrors KERIpy's exposed-prior-next behavior: for each prior next
+     * digest, hash the current verifier key using that digest's code and compare
+     * the result to the digest at that position. A match means the signer has
+     * exposed that precommitted key, and the matching position is the `ondex`.
+     */
+    priorNextIndexForKey(key) {
+        const verfer = new Verfer({ qb64: key });
+        for (const [index, ndig] of this.gpndigs.entries()) {
+            const priorDiger = new Diger({ qb64: ndig });
+            const keyDigest = new Diger({ code: priorDiger.code }, verfer.qb64b)
+                .qb64;
+            if (keyDigest === priorDiger.qb64) {
+                return index;
+            }
+        }
+        return -1;
+    }
     params() {
         return {
             mhab: this.mhab,

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

@@ -1,85 +1,99 @@
-import { Algos } from './manager.ts';
-import { Tier } from './salter.ts';
-export interface KeyState {
-    vn: [number, number];
-    i: string;
-    s: string;
-    p?: string;
-    d: string;
-    f: string;
-    dt: string;
-    et: string;
-    kt: string | string[];
-    k: string[];
-    nt: string | string[];
-    n: string[];
-    bt: string;
-    b: string[];
-    c: string[];
-    ee: EstablishmentState;
-    di?: string;
-}
-export interface EstablishmentState {
-    d: string;
-    s: string;
-}
+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 {
 }
 /**
- * Interface defining configuration parameters for a specified, deterministic salt of an IdentifierManager.
+ * Defining configuration parameters for a specified, deterministic salt of an IdentifierManager.
  */
-export interface SaltyKeyState extends IdentifierManagerState {
-    /**
-     * Encrypted
-     */
-    sxlt: string;
-    pidx: number;
-    kidx: number;
-    stem: string;
-    tier: Tier;
-    dcode: string;
-    icodes: string[];
-    ncodes: string[];
-    transferable: boolean;
-}
+export type SaltyKeyState = components['schemas']['SaltyState'];
 /**
- * Interface defining configuration parameters for a random seed identifier manager.
+ * Defining configuration parameters for a random seed identifier manager.
  */
-export interface RandyKeyState extends IdentifierManagerState {
-    prxs: string[];
-    nxts: string[];
-}
+export type RandyKeyState = components['schemas']['RandyKeyState'];
 /**
- * Interface defining properties a multi-signature group identifier manager.
+ * Defining properties a multi-signature group identifier manager.
  */
-export interface GroupKeyState extends IdentifierManagerState {
-    mhab: HabState;
-    keys: string[];
-    ndigs: string[];
-}
+export type GroupKeyState = components['schemas']['GroupKeyState'];
 /**
- * Interface defining properties for an external module identifier manager that uses externally managed keys such as in an HSM or a KMS system.
+ * Defining properties for an external module identifier manager that uses externally managed keys such as in an HSM or a KMS system.
  */
-export interface ExternState extends IdentifierManagerState {
-    extern_type: string;
-    pidx: number;
-    [key: string]: unknown;
-}
+export type ExternState = components['schemas']['ExternState'];
 /**
- * Interface defining properties of an identifier habitat, know as a Hab in KERIpy.
+ * Defining properties of an identifier habitat, know as a Hab in KERIpy.
  */
-export interface HabState {
-    name: string;
-    prefix: string;
-    transferable: boolean;
-    state: KeyState;
-    windexes: unknown[];
-    icp_dt: string;
-    [Algos.salty]?: SaltyKeyState;
-    [Algos.randy]?: RandyKeyState;
-    [Algos.group]?: GroupKeyState;
-    [Algos.extern]?: ExternState;
-}
+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;
+export type EndRole = components['schemas']['EndRole'];

package/dist/keri/core/keyState.js

@@ -1 +1 @@
-import { Algos } from "./manager.js";
+export {};

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

@@ -242,7 +242,7 @@ interface SignArgs {
     verfers?: Array<Verfer> | undefined;
     indexed?: boolean;
     indices?: Array<number> | undefined;
-    ondices?: Array<number> | undefined;
+    ondices?: Array<number | undefined> | undefined;
 }
 /**
  * Manages key pair creation, retrieval, and message signing.

package/dist/keri/core/manager.js

@@ -722,14 +722,14 @@ export class Manager {
                 let o;
                 if (ondices != undefined) {
                     o = ondices[idx];
-                    if (o <= 0) {
-                        throw new Error(`Invalid other signing index = {o}, not None or not whole number.`);
+                    if (o !== undefined && (!Number.isInteger(o) || o < 0)) {
+                        throw new Error(`Invalid other signing index = ${o}, not None or not whole number.`);
                     }
                 }
                 else {
                     o = i;
                 }
-                const only = o == undefined;
+                const only = o === undefined;
                 sigers.push(signer.sign(ser, i, only, o));
             });
             return sigers;

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

@@ -1,6 +1,6 @@
 import { Matter, MatterArgs } from './matter.ts';
 export declare class CesrNumber extends Matter {
-    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, num?: number | string, numh?: string);
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, num?: number | string);
     get num(): number;
     get numh(): string;
     get positive(): boolean;