signify-ts 0.3.0-rc2 → 0.4.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/app/signaling.d.ts

@@ -0,0 +1,50 @@
+import { SignifyClient } from './clienting.ts';
+/**
+ * KERIA agent-signed KERI reply envelope carried as SSE event data.
+ *
+ * The envelope format is generic. Topic modules decide which reply route and
+ * payload fields they understand, but they should all reuse
+ * `AgentSignals.verifyReplyEnvelope` before auto-approving edge-signed work.
+ */
+export interface SignedReplyEnvelope {
+    rpy: Record<string, unknown>;
+    sigs: string[];
+}
+/**
+ * Optional constraints applied while verifying a signed reply envelope.
+ */
+export interface VerifyReplyEnvelopeOptions {
+    /**
+     * Expected KERI reply route, such as `/test/signals/request`.
+     */
+    route?: string;
+}
+/**
+ * Generic signaling API for one connected KERIA agent.
+ *
+ * This class intentionally owns only live transport and server-authentication
+ * checks. Topic-specific modules use it, but do not own it. SSE delivery is
+ * transient, so topic modules must still provide durable
+ * polling fallback endpoints for missed events and restarts.
+ */
+export declare class AgentSignals {
+    client: SignifyClient;
+    constructor(client: SignifyClient);
+    /**
+     * Open KERIA's authenticated generic agent SSE stream.
+     *
+     * Browser `EventSource` cannot attach Signify authentication headers, so
+     * consumers should use this signed `fetch` response and parse SSE frames
+     * from the returned body stream.
+     */
+    stream(): Promise<Response>;
+    /**
+     * Verify one KERIA agent-signed KERI `rpy` envelope.
+     *
+     * Verification is route-agnostic by default. Pass `options.route` when a
+     * caller is expecting a specific topic request. The payload must name the
+     * connected KERIA agent in `rpy.a.agent`, and the first signature must verify
+     * against the connected agent verifier.
+     */
+    verifyReplyEnvelope(envelope: SignedReplyEnvelope, options?: VerifyReplyEnvelopeOptions): boolean;
+}

package/dist/keri/app/signaling.js

@@ -0,0 +1,52 @@
+import { Serder } from "../core/serder.js";
+import { Siger } from "../core/siger.js";
+/**
+ * Generic signaling API for one connected KERIA agent.
+ *
+ * This class intentionally owns only live transport and server-authentication
+ * checks. Topic-specific modules use it, but do not own it. SSE delivery is
+ * transient, so topic modules must still provide durable
+ * polling fallback endpoints for missed events and restarts.
+ */
+export class AgentSignals {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Open KERIA's authenticated generic agent SSE stream.
+     *
+     * Browser `EventSource` cannot attach Signify authentication headers, so
+     * consumers should use this signed `fetch` response and parse SSE frames
+     * from the returned body stream.
+     */
+    async stream() {
+        const headers = new Headers({ Accept: 'text/event-stream' });
+        return await this.client.fetch('/signals/stream', 'GET', null, headers);
+    }
+    /**
+     * Verify one KERIA agent-signed KERI `rpy` envelope.
+     *
+     * Verification is route-agnostic by default. Pass `options.route` when a
+     * caller is expecting a specific topic request. The payload must name the
+     * connected KERIA agent in `rpy.a.agent`, and the first signature must verify
+     * against the connected agent verifier.
+     */
+    verifyReplyEnvelope(envelope, options = {}) {
+        var _a;
+        if (this.client.agent === null || this.client.agent.verfer === null) {
+            throw new Error('client must be connected before verification');
+        }
+        const rpy = new Serder(envelope.rpy);
+        if (options.route !== undefined && rpy.sad.r !== options.route) {
+            return false;
+        }
+        if (((_a = rpy.sad.a) === null || _a === void 0 ? void 0 : _a.agent) !== this.client.agent.pre) {
+            return false;
+        }
+        if (envelope.sigs.length === 0) {
+            return false;
+        }
+        const siger = new Siger({ qb64: envelope.sigs[0] });
+        return this.client.agent.verfer.verify(siger.raw, rpy.raw);
+    }
+}