signify-ts 0.2.1 → 0.3.0-dev.e31e78d

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

@@ -1,6 +1,237 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
-import { Serder } from '../core/serder';
+import { SignifyClient } from './clienting.ts';
+import { Dict } from '../core/core.ts';
+import { Serder } from '../core/serder.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
  */
@@ -23,11 +254,11 @@ export declare class Exchanges {
      * @param datetime
      * @param dig
      */
-    createExchangeMessage(sender: Dict<any>, route: string, payload: Dict<any>, embeds: Dict<any>, recipient?: string, datetime?: string, dig?: string): Promise<[Serder, string[], string]>;
+    createExchangeMessage(sender: HabState, route: string, payload: Dict<any>, embeds: Dict<any>, recipient: string, datetime?: string, dig?: string): Promise<[Serder, string[], string]>;
     /**
      * 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
@@ -36,11 +267,11 @@ export declare class Exchanges {
      * @param embeds
      * @param recipients
      */
-    send(name: string, topic: string, sender: Dict<any>, 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
@@ -48,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 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

@@ -0,0 +1,242 @@
+import { b, d, Protocols, Ilks, Serials, versify } from "../core/core.js";
+import { Serder } from "../core/serder.js";
+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
+ */
+export class Exchanges {
+    /**
+     * Exchanges
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create exn message
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipient
+     * @param datetime
+     * @param dig
+     */
+    async createExchangeMessage(sender, route, payload, embeds, recipient, datetime, dig) {
+        const keeper = this.client.manager.get(sender);
+        const [exn, end] = exchange(route, payload, sender['prefix'], recipient, datetime, dig, undefined, embeds);
+        const sigs = await keeper.sign(b(exn.raw));
+        return [exn, sigs, d(end)];
+    }
+    /**
+     * Send exn messages to list of recipients
+     * @async
+     * @returns {Promise<Exn>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipients
+     */
+    async send(name, topic, sender, route, payload, embeds, recipients) {
+        for (const recipient of recipients) {
+            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 message to list of recipients
+     * @async
+     * @returns {Promise<Exn>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param exn
+     * @param sigs
+     * @param atc
+     * @param recipients
+     */
+    async sendFromEvents(name, topic, exn, sigs, atc, recipients) {
+        const path = `/identifiers/${name}/exchanges`;
+        const method = 'POST';
+        const data = {
+            tpc: topic,
+            exn: exn.sad,
+            sigs: sigs,
+            atc: atc,
+            rec: recipients,
+        };
+        const res = await this.client.fetch(path, method, data);
+        return await res.json();
+    }
+    /**
+     * Get exn message by said
+     * @async
+     * @returns A promise to the exn message
+     * @param said The said of the exn message
+     */
+    async get(said) {
+        const path = `/exchanges/${said}`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+}
+export function exchange(route, payload, sender, recipient, date, dig, modifiers, embeds) {
+    const vs = versify(Protocols.KERI, undefined, Serials.JSON, 0);
+    const ilk = Ilks.exn;
+    const dt = date !== undefined
+        ? date
+        : nowUTC().toISOString().replace('Z', '000+00:00');
+    const p = dig !== undefined ? dig : '';
+    const q = modifiers !== undefined ? modifiers : {};
+    const ems = embeds != undefined ? embeds : {};
+    let e = {};
+    let end = '';
+    Object.entries(ems).forEach(([key, value]) => {
+        const serder = value[0];
+        const atc = value[1];
+        e[key] = serder.sad;
+        if (atc == undefined) {
+            return;
+        }
+        let pathed = '';
+        const pather = new Pather({}, undefined, ['e', key]);
+        pathed += pather.qb64;
+        pathed += atc;
+        const counter = new Counter({
+            code: CtrDex.PathedMaterialQuadlets,
+            count: Math.floor(pathed.length / 4),
+        });
+        end += counter.qb64;
+        end += pathed;
+    });
+    if (Object.keys(e).length > 0) {
+        e['d'] = '';
+        [, e] = Saider.saidify(e);
+    }
+    const attrs = {};
+    attrs['i'] = recipient;
+    const a = Object.assign(Object.assign({}, attrs), payload);
+    const _sad = {
+        v: vs,
+        t: ilk,
+        d: '',
+        i: sender,
+        rp: recipient,
+        p: p,
+        dt: dt,
+        r: route,
+        q: q,
+        a: a,
+        e: e,
+    };
+    const [, sad] = Saider.saidify(_sad);
+    const exn = new Serder(sad);
+    return [exn, b(end)];
+}

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

@@ -1,5 +1,7 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
+import { SignifyClient } from './clienting.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/{src/keri/app/grouping.ts → dist/keri/app/grouping.js}

@@ -1,48 +1,36 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
-
 /**
  * Groups
  */
 export class Groups {
-    client: SignifyClient;
-
     /**
      * Groups
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * 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: string): Promise<any> {
+    async getRequest(said) {
         const path = `/multisig/request/` + said;
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);
         return await res.json();
     }
-
     /**
      * 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: string,
-        exn: Dict<any>,
-        sigs: string[],
-        atc: string
-    ): Promise<any> {
+    async sendRequest(name, exn, sigs, atc) {
         const path = `/identifiers/${name}/multisig/request`;
         const method = 'POST';
         const data = {
@@ -53,7 +41,6 @@ export class Groups {
         const res = await this.client.fetch(path, method, data);
         return await res.json();
     }
-
     /**
      * 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.
@@ -64,21 +51,15 @@ 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: string,
-        rot: any,
-        sigs: any, //string[],
-        gid: string,
-        smids: string[],
-        rmids: string[]
-    ): Promise<any> {
+    async join(name, rot, sigs, //string[],
+    gid, smids, rmids) {
         const path = `/identifiers/${name}/multisig/join`;
         const method = 'POST';
         const data = {
             tpc: 'multisig',
-            rot: rot.ked,
+            rot: rot.sad,
             sigs: sigs,
             gid: gid,
             smids: smids,

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

@@ -1,5 +1,5 @@
-import { Manager } from '../core/manager';
-import { Serder } from '../core/serder';
+import { Manager } from '../core/manager.ts';
+import { Serder } from '../core/serder.ts';
 export declare class TraitCodex {
     EstOnly: string;
     DoNotDelegate: string;