signify-ts 0.3.0-rc2 → 0.3.0

package/dist/keri/app/exchanging.d.ts

@@ -1,7 +1,237 @@
 import { SignifyClient } from './clienting.ts';
 import { Dict } from '../core/core.ts';
 import { Serder } from '../core/serder.ts';
-import { HabState } from '../core/keyState.ts';
+import { Dip, ExnV1, HabState, Icp, Ixn } from '../core/keyState.ts';
+import { Rpy } from './escrowing.ts';
+import { components } from '../../types/keria-api-schema.ts';
+export type Exn = components['schemas']['Exn'];
+export type ExchangeResource = components['schemas']['ExchangeResource'];
+export type ExchangeResourceV1 = Omit<ExchangeResource, 'exn'> & {
+    exn: ExnV1;
+};
+export type ExnMultisig = components['schemas']['ExnMultisig'];
+export declare const MULTISIG_ICP_ROUTE = "/multisig/icp";
+export declare const MULTISIG_ROT_ROUTE = "/multisig/rot";
+export declare const MULTISIG_IXN_ROUTE = "/multisig/ixn";
+export declare const MULTISIG_RPY_ROUTE = "/multisig/rpy";
+export declare const MULTISIG_VCP_ROUTE = "/multisig/vcp";
+export declare const MULTISIG_ISS_ROUTE = "/multisig/iss";
+export declare const MULTISIG_EXN_ROUTE = "/multisig/exn";
+export declare const MULTISIG_REV_ROUTE = "/multisig/rev";
+export declare const IPEX_GRANT_ROUTE = "/ipex/grant";
+export declare const IPEX_OFFER_ROUTE = "/ipex/offer";
+export declare const IPEX_APPLY_ROUTE = "/ipex/apply";
+export declare const IPEX_AGREE_ROUTE = "/ipex/agree";
+export declare const IPEX_ADMIT_ROUTE = "/ipex/admit";
+export type AnchorEvent = components['schemas']['IXN_V_1'] | components['schemas']['ICP_V_1'] | components['schemas']['ROT_V_1'] | components['schemas']['DIP_V_1'] | components['schemas']['DIP_V_2'];
+export type MultisigIcpExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_ICP_ROUTE;
+        e: {
+            icp: Icp | Dip;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            smids: string[];
+            rmids?: string[];
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigRotExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_ROT_ROUTE;
+        e: {
+            rot: components['schemas']['ROT_V_1'];
+            d?: string;
+        };
+        a: {
+            gid: string;
+            smids: string[];
+            rmids?: string[];
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigIxnExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_IXN_ROUTE;
+        e: {
+            ixn: Ixn;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            smids: string[];
+            rmids?: string[];
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigRpyExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_RPY_ROUTE;
+        e: {
+            rpy: Rpy;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigVcpExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_VCP_ROUTE;
+        e: {
+            vcp: components['schemas']['VCP_V_1'];
+            anc: AnchorEvent;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            usage?: string;
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigIssExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_ISS_ROUTE;
+        e: {
+            acdc: components['schemas']['ACDC_V_1'];
+            iss: components['schemas']['ISS_V_1'];
+            anc: AnchorEvent;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigExnExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_EXN_ROUTE;
+        e: {
+            exn: ExnV1;
+            d?: string;
+        };
+        a: {
+            gid: string;
+            [key: string]: unknown;
+        };
+    };
+};
+export type MultisigRevExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof MULTISIG_REV_ROUTE;
+        e: {
+            rev: components['schemas']['REV_V_1'];
+            d?: string;
+        };
+        a: {
+            gid: string;
+            [key: string]: unknown;
+        };
+    };
+};
+type WithGroupMetadata = Pick<ExnMultisig, 'paths' | 'groupName' | 'memberName' | 'sender'>;
+export type MultisigIcpGroup = Omit<MultisigIcpExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigRotGroup = Omit<MultisigRotExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigIxnGroup = Omit<MultisigIxnExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigRpyGroup = Omit<MultisigRpyExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigVcpGroup = Omit<MultisigVcpExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigIssGroup = Omit<MultisigIssExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigExnGroup = Omit<MultisigExnExchange, 'pathed'> & WithGroupMetadata;
+export type MultisigRevGroup = Omit<MultisigRevExchange, 'pathed'> & WithGroupMetadata;
+export type IpexGrantExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof IPEX_GRANT_ROUTE;
+        e: {
+            acdc: components['schemas']['ACDC_V_1'];
+            iss: components['schemas']['ISS_V_1'];
+            anc: AnchorEvent;
+            d?: string;
+        };
+    };
+};
+export type IpexOfferExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof IPEX_OFFER_ROUTE;
+        e: {
+            acdc: components['schemas']['ACDC_V_1'];
+            d?: string;
+        };
+    };
+};
+export type IpexApplyExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof IPEX_APPLY_ROUTE;
+        e: object;
+    };
+};
+export type IpexAgreeExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof IPEX_AGREE_ROUTE;
+        e: object;
+    };
+};
+export type IpexAdmitExchange = ExchangeResourceV1 & {
+    exn: ExnV1 & {
+        r: typeof IPEX_ADMIT_ROUTE;
+        e: object;
+    };
+};
+export declare function isMultisigIcp(msg: ExchangeResourceV1): msg is MultisigIcpExchange;
+export declare function isMultisigIcp(msg: ExnMultisig): msg is MultisigIcpGroup;
+export declare function isMultisigRot(msg: ExchangeResourceV1): msg is MultisigRotExchange;
+export declare function isMultisigRot(msg: ExnMultisig): msg is MultisigRotGroup;
+export declare function isMultisigIxn(msg: ExchangeResourceV1): msg is MultisigIxnExchange;
+export declare function isMultisigIxn(msg: ExnMultisig): msg is MultisigIxnGroup;
+export declare function isMultisigRpy(msg: ExchangeResourceV1): msg is MultisigRpyExchange;
+export declare function isMultisigRpy(msg: ExnMultisig): msg is MultisigRpyGroup;
+export declare function isMultisigVcp(msg: ExchangeResourceV1): msg is MultisigVcpExchange;
+export declare function isMultisigVcp(msg: ExnMultisig): msg is MultisigVcpGroup;
+export declare function isMultisigIss(msg: ExchangeResourceV1): msg is MultisigIssExchange;
+export declare function isMultisigIss(msg: ExnMultisig): msg is MultisigIssGroup;
+export declare function isMultisigExn(msg: ExchangeResourceV1): msg is MultisigExnExchange;
+export declare function isMultisigExn(msg: ExnMultisig): msg is MultisigExnGroup;
+export declare function isMultisigRev(msg: ExchangeResourceV1): msg is MultisigRevExchange;
+export declare function isMultisigRev(msg: ExnMultisig): msg is MultisigRevGroup;
+export declare function isIpexGrant(msg: ExchangeResourceV1): msg is IpexGrantExchange;
+export declare function isIpexOffer(msg: ExchangeResourceV1): msg is IpexOfferExchange;
+export declare function isIpexApply(msg: ExchangeResourceV1): msg is IpexApplyExchange;
+export declare function isIpexAgree(msg: ExchangeResourceV1): msg is IpexAgreeExchange;
+export declare function isIpexAdmit(msg: ExchangeResourceV1): msg is IpexAdmitExchange;
+export declare function assertMultisigIss(msg: ExchangeResourceV1): MultisigIssExchange;
+export declare function assertMultisigIss(msg: ExnMultisig): MultisigIssGroup;
+export declare function assertMultisigIcp(msg: ExchangeResourceV1): MultisigIcpExchange;
+export declare function assertMultisigIcp(msg: ExnMultisig): MultisigIcpGroup;
+export declare function assertMultisigRot(msg: ExchangeResourceV1): MultisigRotExchange;
+export declare function assertMultisigRot(msg: ExnMultisig): MultisigRotGroup;
+export declare function assertMultisigIxn(msg: ExchangeResourceV1): MultisigIxnExchange;
+export declare function assertMultisigIxn(msg: ExnMultisig): MultisigIxnGroup;
+export declare function assertMultisigRpy(msg: ExchangeResourceV1): MultisigRpyExchange;
+export declare function assertMultisigRpy(msg: ExnMultisig): MultisigRpyGroup;
+export declare function assertMultisigVcp(msg: ExchangeResourceV1): MultisigVcpExchange;
+export declare function assertMultisigVcp(msg: ExnMultisig): MultisigVcpGroup;
+export declare function assertMultisigExn(msg: ExchangeResourceV1): MultisigExnExchange;
+export declare function assertMultisigExn(msg: ExnMultisig): MultisigExnGroup;
+export declare function assertMultisigRev(msg: ExchangeResourceV1): MultisigRevExchange;
+export declare function assertMultisigRev(msg: ExnMultisig): MultisigRevGroup;
+export declare function assertIpexGrant(msg: ExchangeResourceV1): IpexGrantExchange;
+export declare function assertIpexGrant(msg: ExnMultisig): ExnMultisig;
+export declare function assertIpexOffer(msg: ExchangeResourceV1): IpexOfferExchange;
+export declare function assertIpexOffer(msg: ExnMultisig): ExnMultisig;
+export declare function assertIpexApply(msg: ExchangeResourceV1): IpexApplyExchange;
+export declare function assertIpexApply(msg: ExnMultisig): ExnMultisig;
+export declare function assertIpexAgree(msg: ExchangeResourceV1): IpexAgreeExchange;
+export declare function assertIpexAgree(msg: ExnMultisig): ExnMultisig;
+export declare function assertIpexAdmit(msg: ExchangeResourceV1): IpexAdmitExchange;
+export declare function assertIpexAdmit(msg: ExnMultisig): ExnMultisig;
 /**
  * Exchanges
  */
@@ -28,7 +258,7 @@ export declare class Exchanges {
     /**
      * Send exn messages to list of recipients
      * @async
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      * @param name
      * @param topic
      * @param sender
@@ -37,11 +267,11 @@ export declare class Exchanges {
      * @param embeds
      * @param recipients
      */
-    send(name: string, topic: string, sender: HabState, route: string, payload: Dict<any>, embeds: Dict<any>, recipients: string[]): Promise<any>;
+    send(name: string, topic: string, sender: HabState, route: string, payload: Dict<any>, embeds: Dict<any>, recipients: string[]): Promise<Exn>;
     /**
-     * Send exn messaget to list of recipients
+     * Send exn message to list of recipients
      * @async
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      * @param name
      * @param topic
      * @param exn
@@ -49,13 +279,14 @@ export declare class Exchanges {
      * @param atc
      * @param recipients
      */
-    sendFromEvents(name: string, topic: string, exn: Serder, sigs: string[], atc: string, recipients: string[]): Promise<any>;
+    sendFromEvents(name: string, topic: string, exn: Serder, sigs: string[], atc: string, recipients: string[]): Promise<Exn>;
     /**
      * Get exn message by said
      * @async
      * @returns A promise to the exn message
      * @param said The said of the exn message
      */
-    get(said: string): Promise<any>;
+    get(said: string): Promise<ExchangeResourceV1>;
 }
 export declare function exchange(route: string, payload: Dict<any>, sender: string, recipient: string, date?: string, dig?: string, modifiers?: Dict<any>, embeds?: Dict<any>): [Serder, Uint8Array];
+export {};

package/dist/keri/app/exchanging.js

@@ -4,6 +4,104 @@ import { nowUTC } from "../core/utils.js";
 import { Pather } from "../core/pather.js";
 import { Counter, CtrDex } from "../core/counter.js";
 import { Saider } from "../core/saider.js";
+export const MULTISIG_ICP_ROUTE = '/multisig/icp';
+export const MULTISIG_ROT_ROUTE = '/multisig/rot';
+export const MULTISIG_IXN_ROUTE = '/multisig/ixn';
+export const MULTISIG_RPY_ROUTE = '/multisig/rpy';
+export const MULTISIG_VCP_ROUTE = '/multisig/vcp';
+export const MULTISIG_ISS_ROUTE = '/multisig/iss';
+export const MULTISIG_EXN_ROUTE = '/multisig/exn';
+export const MULTISIG_REV_ROUTE = '/multisig/rev';
+export const IPEX_GRANT_ROUTE = '/ipex/grant';
+export const IPEX_OFFER_ROUTE = '/ipex/offer';
+export const IPEX_APPLY_ROUTE = '/ipex/apply';
+export const IPEX_AGREE_ROUTE = '/ipex/agree';
+export const IPEX_ADMIT_ROUTE = '/ipex/admit';
+export function isMultisigIcp(msg) {
+    return msg.exn.r === MULTISIG_ICP_ROUTE;
+}
+export function isMultisigRot(msg) {
+    return msg.exn.r === MULTISIG_ROT_ROUTE;
+}
+export function isMultisigIxn(msg) {
+    return msg.exn.r === MULTISIG_IXN_ROUTE;
+}
+export function isMultisigRpy(msg) {
+    return msg.exn.r === MULTISIG_RPY_ROUTE;
+}
+export function isMultisigVcp(msg) {
+    return msg.exn.r === MULTISIG_VCP_ROUTE;
+}
+export function isMultisigIss(msg) {
+    return msg.exn.r === MULTISIG_ISS_ROUTE;
+}
+export function isMultisigExn(msg) {
+    return msg.exn.r === MULTISIG_EXN_ROUTE;
+}
+export function isMultisigRev(msg) {
+    return msg.exn.r === MULTISIG_REV_ROUTE;
+}
+export function isIpexGrant(msg) {
+    return msg.exn.r === IPEX_GRANT_ROUTE;
+}
+export function isIpexOffer(msg) {
+    return msg.exn.r === IPEX_OFFER_ROUTE;
+}
+export function isIpexApply(msg) {
+    return msg.exn.r === IPEX_APPLY_ROUTE;
+}
+export function isIpexAgree(msg) {
+    return msg.exn.r === IPEX_AGREE_ROUTE;
+}
+export function isIpexAdmit(msg) {
+    return msg.exn.r === IPEX_ADMIT_ROUTE;
+}
+function assertRoute(msg, route, label) {
+    var _a, _b;
+    if (((_a = msg.exn) === null || _a === void 0 ? void 0 : _a.r) !== route) {
+        throw new Error(`Expected ${label} but got route: ${(_b = msg.exn) === null || _b === void 0 ? void 0 : _b.r}`);
+    }
+    return msg;
+}
+export function assertMultisigIss(msg) {
+    return assertRoute(msg, MULTISIG_ISS_ROUTE, 'Multisig ISS message');
+}
+export function assertMultisigIcp(msg) {
+    return assertRoute(msg, MULTISIG_ICP_ROUTE, 'Multisig ICP message');
+}
+export function assertMultisigRot(msg) {
+    return assertRoute(msg, MULTISIG_ROT_ROUTE, 'Multisig ROT message');
+}
+export function assertMultisigIxn(msg) {
+    return assertRoute(msg, MULTISIG_IXN_ROUTE, 'Multisig IXN message');
+}
+export function assertMultisigRpy(msg) {
+    return assertRoute(msg, MULTISIG_RPY_ROUTE, 'Multisig RPY message');
+}
+export function assertMultisigVcp(msg) {
+    return assertRoute(msg, MULTISIG_VCP_ROUTE, 'Multisig VCP message');
+}
+export function assertMultisigExn(msg) {
+    return assertRoute(msg, MULTISIG_EXN_ROUTE, 'Multisig EXN message');
+}
+export function assertMultisigRev(msg) {
+    return assertRoute(msg, MULTISIG_REV_ROUTE, 'Multisig REV message');
+}
+export function assertIpexGrant(msg) {
+    return assertRoute(msg, IPEX_GRANT_ROUTE, 'IPEX grant message');
+}
+export function assertIpexOffer(msg) {
+    return assertRoute(msg, IPEX_OFFER_ROUTE, 'IPEX offer message');
+}
+export function assertIpexApply(msg) {
+    return assertRoute(msg, IPEX_APPLY_ROUTE, 'IPEX apply message');
+}
+export function assertIpexAgree(msg) {
+    return assertRoute(msg, IPEX_AGREE_ROUTE, 'IPEX agree message');
+}
+export function assertIpexAdmit(msg) {
+    return assertRoute(msg, IPEX_ADMIT_ROUTE, 'IPEX admit message');
+}
 /**
  * Exchanges
  */
@@ -36,7 +134,7 @@ export class Exchanges {
     /**
      * Send exn messages to list of recipients
      * @async
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      * @param name
      * @param topic
      * @param sender
@@ -50,11 +148,12 @@ export class Exchanges {
             const [exn, sigs, atc] = await this.createExchangeMessage(sender, route, payload, embeds, recipient);
             return await this.sendFromEvents(name, topic, exn, sigs, atc, recipients);
         }
+        throw new Error('recipients list was empty');
     }
     /**
-     * Send exn messaget to list of recipients
+     * Send exn message to list of recipients
      * @async
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      * @param name
      * @param topic
      * @param exn

package/dist/keri/app/grouping.d.ts

@@ -1,5 +1,7 @@
 import { SignifyClient } from './clienting.ts';
-import { Dict } from '../core/core.ts';
+import { GroupOperation } from '../core/keyState.ts';
+import { ExnMultisig } from './exchanging.ts';
+import { Exn } from './exchanging.ts';
 /**
  * Groups
  */
@@ -14,19 +16,19 @@ export declare class Groups {
      * Get group request messages
      * @async
      * @param {string} [said] SAID of exn message to load
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<ExnMultisig[]>} A promise to the list of replay messages
      */
-    getRequest(said: string): Promise<any>;
+    getRequest(said: string): Promise<ExnMultisig[]>;
     /**
      * Send multisig exn request  messages to other group members
      * @async
      * @param {string} [name] human readable name of group AID
-     * @param {Dict<any>} [exn] exn message to send to other members
+     * @param {Exn} [exn] exn message to send to other members
      * @param {string[]} [sigs] signature of the participant over the exn
      * @param {string} [atc] additional attachments from embedded events in exn
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      */
-    sendRequest(name: string, exn: Dict<any>, sigs: string[], atc: string): Promise<any>;
+    sendRequest(name: string, exn: Exn, sigs: string[], atc: string): Promise<Exn>;
     /**
      * Join multisig group using rotation event.
      * This can be used by participants being asked to contribute keys to a rotation event to join an existing group.
@@ -37,8 +39,8 @@ export declare class Groups {
      * @param {string} [gid] prefix
      * @param {string[]} [smids] array of particpants
      * @param {string[]} [rmids] array of particpants
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<GroupOperation>} A promise to the list of replay messages
      */
     join(name: string, rot: any, sigs: any, //string[],
-    gid: string, smids: string[], rmids: string[]): Promise<any>;
+    gid: string, smids: string[], rmids: string[]): Promise<GroupOperation>;
 }

package/dist/keri/app/grouping.js

@@ -13,7 +13,7 @@ export class Groups {
      * Get group request messages
      * @async
      * @param {string} [said] SAID of exn message to load
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<ExnMultisig[]>} A promise to the list of replay messages
      */
     async getRequest(said) {
         const path = `/multisig/request/` + said;
@@ -25,10 +25,10 @@ export class Groups {
      * Send multisig exn request  messages to other group members
      * @async
      * @param {string} [name] human readable name of group AID
-     * @param {Dict<any>} [exn] exn message to send to other members
+     * @param {Exn} [exn] exn message to send to other members
      * @param {string[]} [sigs] signature of the participant over the exn
      * @param {string} [atc] additional attachments from embedded events in exn
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Exn>} A promise to the list of replay messages
      */
     async sendRequest(name, exn, sigs, atc) {
         const path = `/identifiers/${name}/multisig/request`;
@@ -51,7 +51,7 @@ export class Groups {
      * @param {string} [gid] prefix
      * @param {string[]} [smids] array of particpants
      * @param {string[]} [rmids] array of particpants
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<GroupOperation>} A promise to the list of replay messages
      */
     async join(name, rot, sigs, //string[],
     gid, smids, rmids) {

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

@@ -26,9 +26,9 @@ export declare function rotate({ pre, keys, dig, ilk, sn, isith, ndigs, nsith, w
 export declare function ample(n: number, f?: number, weak?: boolean): number;
 export interface InceptArgs {
     keys: Array<string>;
-    isith?: number | string | Array<string>;
+    isith?: string | number | string[] | string[][];
     ndigs?: Array<string>;
-    nsith?: number | string | Array<string>;
+    nsith?: string | number | string[] | string[][];
     toad?: number | string;
     wits?: Array<string>;
     cnfg?: Array<string>;

package/dist/keri/core/eventing.js

@@ -8,7 +8,7 @@ import { Saider } from "./saider.js";
 import { Counter, CtrDex } from "./counter.js";
 import { Seqner } from "./seqner.js";
 const MaxIntThold = 2 ** 32 - 1;
-export function rotate({ pre = undefined, keys, dig = undefined, ilk = Ilks.rot, sn = 1, isith = undefined, ndigs = undefined, nsith = undefined, wits = undefined, cuts = undefined, adds = undefined, toad = undefined, data = undefined, version = undefined, kind = undefined, intive = true, }) {
+export function rotate({ pre = undefined, keys, dig = undefined, ilk = Ilks.rot, sn = 1, isith = undefined, ndigs = undefined, nsith = undefined, wits = undefined, cuts = [], adds = [], toad = undefined, data = undefined, version = undefined, kind = undefined, intive = true, }) {
     const vs = versify(Protocols.KERI, version, kind, 0);
     const _ilk = ilk;
     if (_ilk != Ilks.rot && _ilk != Ilks.drt) {
@@ -66,25 +66,14 @@ export function rotate({ pre = undefined, keys, dig = undefined, ilk = Ilks.rot,
     if (witset.size != _wits.length) {
         throw new Error(`Invalid wits = ${wits}, has duplicates.`);
     }
-    let _cuts;
-    if (cuts === undefined) {
-        _cuts = [];
-    }
-    else {
-        _cuts = cuts;
-    }
-    const cutset = new Set(_cuts);
-    if (cutset.size != _cuts.length) {
+    const cutset = new Set(cuts);
+    if (cutset.size != cuts.length) {
         throw new Error(`Invalid cuts = ${cuts}, has duplicates.`);
     }
-    let _adds;
-    if (adds === undefined) {
-        _adds = [];
-    }
-    else {
-        _adds = adds;
+    const addset = new Set(adds);
+    if (addset.size != adds.length) {
+        throw new Error(`Invalid adds = ${adds}, has duplicates.`);
     }
-    const addset = new Set(_adds);
     //non empty intersection of witset and addset
     const witaddset = new Set([...witset].filter((x) => addset.has(x)));
     if (witaddset.size > 0) {
@@ -96,7 +85,7 @@ export function rotate({ pre = undefined, keys, dig = undefined, ilk = Ilks.rot,
         throw new Error(`Invalid member combination among cuts = ${cuts}, and adds = ${adds}.`);
     }
     const newitsetdiff = new Set(_wits);
-    _cuts.forEach(function (v) {
+    cuts.forEach(function (v) {
         newitsetdiff.delete(v);
     });
     const newitset = new Set((function* () {

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

@@ -148,7 +148,22 @@ export declare class GroupIdentifierManager implements IdentifierManager {
     rotate(_ncodes: string[], _transferable: boolean, states: KeyState[], rstates: KeyState[]): Promise<IdentifierManagerResult>;
     sign(ser: Uint8Array, indexed?: boolean): Promise<SignResult>;
     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

@@ -57,45 +57,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');
         }
     }
 }