signify-ts 0.2.0 → 0.3.0-rc1

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

@@ -2,6 +2,7 @@ import { SignifyClient } from './clienting';
 import { Dict } from '../core/core';
 import { Serder } from '../core/serder';
 import { Operation } from './coring';
+import { HabState } from '../core/state';
 /** Types of credentials */
 export declare class CredentialTypes {
     static issued: string;
@@ -14,43 +15,56 @@ export interface CredentialFilter {
     skip?: number;
     limit?: number;
 }
-export interface IssueCredentialArgs {
+export interface CredentialSubject {
     /**
-     * Name of the issuer identifier
+     * Issuee, or holder of the credential.
      */
-    issuerName: string;
+    i?: string;
     /**
-     * QB64 AID of credential registry
+     * Timestamp of issuance.
      */
-    registryId: string;
+    dt?: string;
     /**
-     * SAID Of the schema
+     * Privacy salt
      */
-    schemaId: string;
+    u?: string;
+    [key: string]: unknown;
+}
+export interface CredentialData {
+    v?: string;
+    d?: string;
     /**
-     * Prefix of recipient identifier
+     * Privacy salt
      */
-    recipient?: string;
+    u?: string;
     /**
-     * Credential data
+     * Issuer of the credential.
      */
-    data?: Record<string, unknown>;
+    i?: string;
     /**
-     * Credential rules
+     * Registry id.
      */
-    rules?: string | Record<string, unknown>;
+    ri?: string;
     /**
-     * Credential sources
+     * Schema id
      */
-    source?: Record<string, unknown>;
+    s?: string;
     /**
-     * Datetime to set for the credential
+     * Credential subject data
      */
-    datetime?: string;
+    a: CredentialSubject;
+    /**
+     * Credential source section
+     */
+    e?: {
+        [key: string]: unknown;
+    };
     /**
-     * Flag to issue a credential with privacy preserving features
+     * Credential rules section
      */
-    privacy?: boolean;
+    r?: {
+        [key: string]: unknown;
+    };
 }
 export interface IssueCredentialResult {
     acdc: Serder;
@@ -58,6 +72,76 @@ export interface IssueCredentialResult {
     iss: Serder;
     op: Operation;
 }
+export interface RevokeCredentialResult {
+    anc: Serder;
+    rev: Serder;
+    op: Operation;
+}
+export interface IpexApplyArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+    /**
+     * Message to send
+     */
+    message?: string;
+    /**
+     * SAID of schema to apply for
+     */
+    schemaSaid: string;
+    /**
+     * Optional attributes for selective disclosure
+     */
+    attributes?: Record<string, unknown>;
+    datetime?: string;
+}
+export interface IpexOfferArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+    /**
+     * Message to send
+     */
+    message?: string;
+    /**
+     * ACDC to offer
+     */
+    acdc: Serder;
+    /**
+     * Optional qb64 SAID of apply message this offer is responding to
+     */
+    applySaid?: string;
+    datetime?: string;
+}
+export interface IpexAgreeArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+    /**
+     * Message to send
+     */
+    message?: string;
+    /**
+     * qb64 SAID of offer message this agree is responding to
+     */
+    offerSaid: string;
+    datetime?: string;
+}
 export interface IpexGrantArgs {
     /**
      * Alias for the IPEX sender AID
@@ -74,7 +158,7 @@ export interface IpexGrantArgs {
     /**
      * qb64 SAID of agree message this grant is responding to
      */
-    agree?: string;
+    agreeSaid?: string;
     datetime?: string;
     acdc: Serder;
     acdcAttachment?: string;
@@ -83,6 +167,48 @@ export interface IpexGrantArgs {
     anc: Serder;
     ancAttachment?: string;
 }
+export interface IpexAdmitArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+    /**
+     * Message to send
+     */
+    message?: string;
+    /**
+     * qb64 SAID of agree message this admit is responding to
+     */
+    grantSaid: string;
+    datetime?: string;
+}
+export type CredentialState = {
+    vn: [number, number];
+    i: string;
+    s: string;
+    d: string;
+    ri: string;
+    a: {
+        s: number;
+        d: string;
+    };
+    dt: string;
+    et: string;
+} & ({
+    et: 'iss' | 'rev';
+    ra: Record<string, never>;
+} | {
+    et: 'bis' | 'brv';
+    ra: {
+        i: string;
+        s: string;
+        d: string;
+    };
+});
 /**
  * Credentials
  */
@@ -109,37 +235,33 @@ export declare class Credentials {
      */
     get(said: string, includeCESR?: boolean): Promise<any>;
     /**
-     * Issue a credential
+     * Delete a credential from the DB
+     * @async
+     * @param {string} said - SAID of the credential
+     * @returns {Promise<void>}
      */
-    issue(args: IssueCredentialArgs): Promise<IssueCredentialResult>;
+    delete(said: string): Promise<void>;
     /**
-     * Revoke credential
+     * Get the state of a credential
      * @async
-     * @param {string} name Name or alias of the identifier
-     * @param {string} said SAID of the credential
-     * @returns {Promise<any>} A promise to the long-running operation
+     * @param {string} ri - management registry identifier
+     * @param {string} said - SAID of the credential
+     * @returns {Promise<CredentialState>} A promise to the credential registry state
      */
-    revoke(name: string, said: string): Promise<any>;
+    state(ri: string, said: string): Promise<CredentialState>;
     /**
-     * Present a credential
-     * @async
-     * @param {string} name Name or alias of the identifier
-     * @param {string} said SAID of the credential
-     * @param {string} recipient Identifier prefix of the receiver of the presentation
-     * @param {boolean} [include=true] Flag to indicate whether to stream credential alongside presentation exchange message
-     * @returns {Promise<string>} A promise to the long-running operation
+     * Issue a credential
      */
-    present(name: string, said: string, recipient: string, include?: boolean): Promise<string>;
+    issue(name: string, args: CredentialData): Promise<IssueCredentialResult>;
     /**
-     * Request a presentation of a credential
+     * Revoke credential
      * @async
      * @param {string} name Name or alias of the identifier
-     * @param {string} recipient Identifier prefix of the receiver of the presentation
-     * @param {string} schema SAID of the schema
-     * @param {string} [issuer] Optional prefix of the issuer of the credential
-     * @returns {Promise<string>} A promise to the long-running operation
+     * @param {string} said SAID of the credential
+     * @param {string} datetime date time of revocation
+     * @returns {Promise<any>} A promise to the long-running operation
      */
-    request(name: string, recipient: string, schema: string, issuer?: string): Promise<string>;
+    revoke(name: string, said: string, datetime?: string): Promise<RevokeCredentialResult>;
 }
 export interface CreateRegistryArgs {
     name: string;
@@ -184,7 +306,16 @@ export declare class Registries {
      * @returns {Promise<[any, Serder, any[], object]> } A promise to the long-running operation
      */
     create({ name, registryName, noBackers, toad, baks, nonce, }: CreateRegistryArgs): Promise<RegistryResult>;
-    createFromEvents(hab: Dict<any>, name: string, registryName: string, vcp: Dict<any>, ixn: Dict<any>, sigs: any[]): Promise<Response>;
+    createFromEvents(hab: HabState, name: string, registryName: string, vcp: Dict<any>, ixn: Dict<any>, sigs: any[]): Promise<Response>;
+    /**
+     * Rename a registry
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} registryName Current registry name
+     * @param {string} newName New registry name
+     * @returns {Promise<any>} A promise to the registry record
+     */
+    rename(name: string, registryName: string, newName: string): Promise<any>;
 }
 /**
  * Schemas
@@ -220,6 +351,21 @@ export declare class Ipex {
      * @param {SignifyClient} client
      */
     constructor(client: SignifyClient);
+    /**
+     * Create an IPEX apply EXN message
+     */
+    apply(args: IpexApplyArgs): Promise<[Serder, string[], string]>;
+    submitApply(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<any>;
+    /**
+     * Create an IPEX offer EXN message
+     */
+    offer(args: IpexOfferArgs): Promise<[Serder, string[], string]>;
+    submitOffer(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    /**
+     * Create an IPEX agree EXN message
+     */
+    agree(args: IpexAgreeArgs): Promise<[Serder, string[], string]>;
+    submitAgree(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<any>;
     /**
      * Create an IPEX grant EXN message
      */
@@ -227,13 +373,7 @@ export declare class Ipex {
     submitGrant(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
     /**
      * Create an IPEX admit EXN message
-     * @async
-     * @param {string} name Name or alias of the identifier
-     * @param {string} message accompany human readable description of the credential being admitted
-     * @param {string} grant qb64 SAID of grant message this admit is responding to
-     * @param {string} datetime Optional datetime to set for the credential
-     * @returns {Promise<[Serder, string[], string]>} A promise to the long-running operation
      */
-    admit(name: string, message: string, grant: string, datetime?: string): Promise<[Serder, string[], string]>;
+    admit(args: IpexAdmitArgs): Promise<[Serder, string[], string]>;
     submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
 }

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

@@ -0,0 +1,18 @@
+import { EventResult } from './aiding';
+import { SignifyClient } from './clienting';
+export declare class Delegations {
+    client: SignifyClient;
+    /**
+     * Delegations
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Approve the delegation via interaction event
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {any} [data] The anchoring interaction event
+     * @returns {Promise<EventResult>} A promise to the delegated approval result
+     */
+    approve(name: string, data?: any): Promise<EventResult>;
+}

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

@@ -1,6 +1,7 @@
 import { SignifyClient } from './clienting';
 import { Dict } from '../core/core';
 import { Serder } from '../core/serder';
+import { HabState } from '../core/state';
 /**
  * Exchanges
  */
@@ -23,7 +24,7 @@ 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
@@ -36,7 +37,7 @@ 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<any>;
     /**
      * Send exn messaget to list of recipients
      * @async
@@ -57,4 +58,4 @@ export declare class Exchanges {
      */
     get(said: string): Promise<any>;
 }
-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];

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

@@ -28,7 +28,7 @@ export declare class Notifications {
      * Delete a notification
      * @async
      * @param {string} said SAID of the notification
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
     delete(said: string): Promise<void>;
 }

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+export declare function encodeBase64Url(buffer: Buffer): string;
+export declare function decodeBase64Url(input: string): Buffer;

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

@@ -24,6 +24,8 @@ export declare const Ilks: {
     vcp: string;
     iss: string;
     rev: string;
+    bis: string;
+    brv: string;
 };
 export declare const IcpLabels: string[];
 export declare const DipLabels: string[];

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

@@ -1,6 +1,8 @@
 import { Signer } from './signer';
 import { Cigar } from './cigar';
 import { Siger } from './siger';
+export declare const HEADER_SIG_INPUT: string;
+export declare const HEADER_SIG_TIME: string;
 export declare function normalize(header: string): string;
 export interface SiginputArgs {
     name: string;

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

@@ -2,23 +2,56 @@ import { Salter } from './salter';
 import { Algos } from './manager';
 import { Tier } from './salter';
 import { Signer } from './signer';
-import { Siger } from './siger';
-import { Cigar } from './cigar';
-export {};
+import { HabState, State } from './state';
 /** External module definition */
+export interface ExternalModuleType {
+    new (pidx: number, args: KeeperParams): Keeper;
+}
 export interface ExternalModule {
     type: string;
     name: string;
-    module: any;
+    module: ExternalModuleType;
+}
+export type KeeperResult = [string[], string[]];
+export type SignResult = string[];
+export interface KeeperParams {
+    [key: string]: unknown;
+}
+export interface SaltyParams extends KeeperParams {
+    pidx: number;
+    kidx: number;
+    tier: Tier;
+    transferable: boolean;
+    stem: string | undefined;
+    icodes: string[] | undefined;
+    ncodes: string[] | undefined;
+    dcode: string | undefined;
+    sxlt: string | undefined;
+}
+export interface RandyParams extends KeeperParams {
+    nxts?: string[];
+    prxs?: string[];
+    transferable: boolean;
+}
+export interface GroupParams extends KeeperParams {
+    mhab: HabState;
+}
+export interface Keeper<T extends KeeperParams = KeeperParams> {
+    algo: Algos;
+    signers: Signer[];
+    params(): T;
+    incept(transferable: boolean): Promise<KeeperResult>;
+    rotate(ncodes: string[], transferable: boolean, states?: State[], rstates?: State[]): Promise<KeeperResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[], ondices?: number[]): Promise<SignResult>;
 }
 export declare class KeyManager {
-    private salter?;
-    private modules?;
+    private salter;
+    private modules;
     constructor(salter: Salter, externalModules?: ExternalModule[]);
-    new(algo: Algos, pidx: number, kargs: any): any;
-    get(aid: any): any;
+    new(algo: Algos, pidx: number, kargs: any): Keeper<KeeperParams> | GroupKeeper;
+    get(aid: HabState): Keeper;
 }
-export declare class SaltyKeeper {
+export declare class SaltyKeeper implements Keeper {
     private aeid;
     private encrypter;
     private decrypter;
@@ -40,23 +73,13 @@ export declare class SaltyKeeper {
     private creator;
     algo: Algos;
     signers: Signer[];
-    constructor(salter: Salter, pidx: number, kidx?: number, tier?: Tier, transferable?: boolean, stem?: undefined, code?: string, count?: number, icodes?: string[] | undefined, ncode?: string, ncount?: number, ncodes?: string[] | undefined, dcode?: string, bran?: string | undefined, sxlt?: undefined);
-    params(): {
-        sxlt: string | undefined;
-        pidx: number;
-        kidx: number;
-        stem: string | undefined;
-        tier: Tier;
-        icodes: string[] | undefined;
-        ncodes: string[] | undefined;
-        dcode: string | undefined;
-        transferable: boolean;
-    };
-    incept(transferable: boolean): string[][];
-    rotate(ncodes: string[], transferable: boolean, ..._: any[]): string[][];
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): string[];
+    constructor(salter: Salter, pidx: number, kidx?: number, tier?: Tier, transferable?: boolean, stem?: string | undefined, code?: string, count?: number, icodes?: string[] | undefined, ncode?: string, ncount?: number, ncodes?: string[] | undefined, dcode?: string, bran?: string | undefined, sxlt?: string | undefined);
+    params(): SaltyParams;
+    incept(transferable: boolean): Promise<KeeperResult>;
+    rotate(ncodes: string[], transferable: boolean): Promise<[string[], string[]]>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): Promise<SignResult>;
 }
-export declare class RandyKeeper {
+export declare class RandyKeeper implements Keeper {
     private salter;
     private code;
     private count;
@@ -75,29 +98,25 @@ export declare class RandyKeeper {
     algo: Algos;
     signers: Signer[];
     constructor(salter: Salter, code: string | undefined, count: number | undefined, icodes: string[] | undefined, transferable: boolean | undefined, ncode: string | undefined, ncount: number | undefined, ncodes: string[], dcode?: string, prxs?: string[] | undefined, nxts?: string[] | undefined);
-    params(): {
-        nxts: string[] | undefined;
-        prxs: string[] | undefined;
-        transferable: boolean;
-    };
-    incept(transferable: boolean): string[][];
-    rotate(ncodes: string[], transferable: boolean, ..._: any[]): any[][];
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): any[];
+    params(): RandyParams;
+    incept(transferable: boolean): Promise<KeeperResult>;
+    rotate(ncodes: string[], transferable: boolean): Promise<KeeperResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): Promise<SignResult>;
 }
-export declare class GroupKeeper {
+export declare class GroupKeeper implements Keeper {
     private manager;
     private mhab;
     private gkeys;
     private gdigs;
     algo: Algos;
     signers: Signer[];
-    constructor(manager: KeyManager, mhab?: undefined, states?: any[] | undefined, rstates?: any[] | undefined, keys?: any[] | undefined, ndigs?: any[] | undefined);
-    incept(..._: any): (string[] | undefined)[];
-    rotate(_ncodes: string[], _transferable: boolean, states: any[], rstates: any[], ..._: any): string[][];
-    sign(ser: Uint8Array, indexed?: boolean, _indices?: number[] | undefined, _ondices?: number[] | undefined): Promise<Siger[] | Cigar[]>;
+    constructor(manager: KeyManager, mhab: HabState, states?: State[] | undefined, rstates?: State[] | undefined, keys?: string[], ndigs?: string[]);
+    incept(): Promise<KeeperResult>;
+    rotate(_ncodes: string[], _transferable: boolean, states: State[], rstates: State[]): Promise<KeeperResult>;
+    sign(ser: Uint8Array, indexed?: boolean): Promise<SignResult>;
     params(): {
-        mhab: any;
-        keys: string[] | undefined;
-        ndigs: string[] | undefined;
+        mhab: HabState;
+        keys: string[];
+        ndigs: string[];
     };
 }

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Matter, MatterArgs } from './matter';
 import { Dict, Serials } from './core';
+import { Buffer } from 'buffer';
 export declare enum Ids {
     d = "d"
 }

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

@@ -0,0 +1,62 @@
+import { Algos } from './manager';
+import { Tier } from './salter';
+export interface State {
+    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;
+}
+export interface SaltyState {
+    sxlt: string;
+    pidx: number;
+    kidx: number;
+    stem: string;
+    tier: Tier;
+    dcode: string;
+    icodes: string[];
+    ncodes: string[];
+    transferable: boolean;
+}
+export interface RandyState {
+    prxs: string[];
+    nxts: string[];
+}
+export interface GroupState {
+    mhab: HabState;
+    keys: string[];
+    ndigs: string[];
+}
+export interface ExternState {
+    extern_type: string;
+    pidx: number;
+    [key: string]: unknown;
+}
+export interface HabState {
+    name: string;
+    prefix: string;
+    transferable: boolean;
+    state: State;
+    windexes: unknown[];
+    icp_dt: string;
+    [Algos.salty]?: SaltyState;
+    [Algos.randy]?: RandyState;
+    [Algos.group]?: GroupState;
+    [Algos.extern]?: ExternState;
+}

package/dist/keri/end/ending.d.ts

@@ -1,13 +1,15 @@
+import { Siger } from '../core/siger';
+import { Cigar } from '../core/cigar';
 export declare const FALSY: (string | number | boolean)[];
 export declare const TRUTHY: (string | number | boolean)[];
 export declare class Signage {
-    constructor(markers: any, indexed?: boolean, signer?: string, ordinal?: string, digest?: string, kind?: string);
-    markers: any;
-    indexed: boolean | undefined;
-    signer: string | undefined;
-    ordinal: string | undefined;
-    digest: string | undefined;
-    kind: string | undefined;
+    readonly markers: (Siger | Cigar)[] | Map<string, string | Siger | Cigar>;
+    readonly indexed?: boolean | undefined;
+    readonly signer?: string | undefined;
+    readonly ordinal?: string | undefined;
+    readonly digest?: string | undefined;
+    readonly kind?: string | undefined;
+    constructor(markers: (Siger | Cigar)[] | Map<string, string | Siger | Cigar>, indexed?: boolean | undefined, signer?: string | undefined, ordinal?: string | undefined, digest?: string | undefined, kind?: string | undefined);
 }
-export declare function signature(signages: Array<Signage>): Headers;
+export declare function signature(signages: Signage[]): Headers;
 export declare function designature(value: string): Signage[];