signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/{src/keri/app/coring.ts → dist/keri/app/coring.js}

@@ -1,54 +1,47 @@
-import { SignifyClient } from './clienting';
 import libsodium from 'libsodium-wrappers-sumo';
-import { Salter } from '../core/salter';
-import { Matter, MtrDex } from '../core/matter';
-
-export function randomPasscode(): string {
+import { Salter } from "../core/salter.js";
+import { Matter, MtrDex } from "../core/matter.js";
+export function randomPasscode() {
     const raw = libsodium.randombytes_buf(16);
     const salter = new Salter({ raw: raw });
-
-    return salter.qb64.substring(2);
+    // https://github.com/WebOfTrust/signify-ts/issues/242
+    return salter.qb64.substring(2, 23);
 }
-
-export function randomNonce(): string {
+export function randomNonce() {
     const seed = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
     const seedqb64 = new Matter({ raw: seed, code: MtrDex.Ed25519_Seed });
     return seedqb64.qb64;
 }
-
 export class Oobis {
-    public client: SignifyClient;
     /**
      * Oobis
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * Get the OOBI(s) for a managed indentifier for a given role
      * @param {string} name Name or alias of the identifier
      * @param {string} role Authorized role
-     * @returns {Promise<any>} A promise to the OOBI(s)
+     * @returns {Promise<OOBI>} A promise to the OOBI(s)
      */
-    async get(name: string, role: string = 'agent'): Promise<any> {
+    async get(name, role = 'agent') {
         const path = `/identifiers/${name}/oobis?role=${role}`;
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);
         return await res.json();
     }
-
     /**
      * Resolve an OOBI
      * @async
      * @param {string} oobi The OOBI to be resolver
      * @param {string} [alias] Optional name or alias to link the OOBI resolution to a contact
-     * @returns {Promise<any>} A promise to the long-running operation
+     * @returns {Promise<OOBIOperation>} A promise to the long-running operation
      */
-    async resolve(oobi: string, alias?: string): Promise<any> {
+    async resolve(oobi, alias) {
         const path = `/oobis`;
-        const data: any = {
+        const data = {
             url: oobi,
         };
         if (alias !== undefined) {
@@ -59,40 +52,41 @@ export class Oobis {
         return await res.json();
     }
 }
-
-export interface Operation<T = unknown> {
-    name: string;
-    metadata?: {
-        depends?: Operation;
-        [property: string]: any;
-    };
-    done?: boolean;
-    error?: any;
-    response?: T;
-}
-
 /**
  * Operations
  * @remarks
  * Operations represent the status and result of long running tasks performed by KERIA agent
  */
 export class Operations {
-    public client: SignifyClient;
     /**
      * Operations
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
+    hasDepends(op) {
+        return op.metadata !== undefined && 'depends' in op.metadata;
+    }
+    /**
+     * Check if operation failed and throw error with details
+     * @throws {Error} If operation has an error
+     */
+    throwIfFailed(op) {
+        if ('error' in op && op.error !== null) {
+            const details = op.error.details
+                ? ` Details: ${JSON.stringify(op.error.details)}`
+                : '';
+            throw new Error(`Operation '${op.name}' failed [Code ${op.error.code}]: ${op.error.message}${details}`);
+        }
+    }
     /**
      * Get operation status
      * @async
      * @param {string} name Name of the operation
      * @returns {Promise<Operation>} A promise to the status of the operation
      */
-    async get<T = unknown>(name: string): Promise<Operation<T>> {
+    async get(name) {
         const path = `/operations/${name}`;
         const data = null;
         const method = 'GET';
@@ -105,7 +99,7 @@ export class Operations {
      * @param {string} type Select operations by type
      * @returns {Promise<Operation[]>} A list of operations
      */
-    async list(type?: string): Promise<Operation<any>[]> {
+    async list(type) {
         const params = new URLSearchParams();
         if (type !== undefined) {
             params.append('type', type);
@@ -121,34 +115,58 @@ export class Operations {
      * @async
      * @param {string} name Name of the operation
      */
-    async delete(name: string): Promise<void> {
+    async delete(name) {
         const path = `/operations/${name}`;
         const data = null;
         const method = 'DELETE';
         await this.client.fetch(path, method, data);
     }
+    async wait(op, options = {}) {
+        var _a, _b, _c, _d;
+        const minSleep = (_a = options.minSleep) !== null && _a !== void 0 ? _a : 10;
+        const maxSleep = (_b = options.maxSleep) !== null && _b !== void 0 ? _b : 10000;
+        const increaseFactor = (_c = options.increaseFactor) !== null && _c !== void 0 ? _c : 50;
+        if (this.hasDepends(op) &&
+            op.metadata.depends &&
+            !op.metadata.depends.done) {
+            await this.wait(op.metadata.depends, options);
+        }
+        if (op.done === true) {
+            this.throwIfFailed(op);
+            return op;
+        }
+        let retries = 0;
+        while (true) {
+            op = await this.get(op.name);
+            if (op.done === true) {
+                this.throwIfFailed(op);
+                return op;
+            }
+            const delay = Math.max(minSleep, Math.min(maxSleep, 2 ** retries * increaseFactor));
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            (_d = options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
+        }
+    }
 }
-
 /**
  * KeyEvents
  */
 export class KeyEvents {
-    public client: SignifyClient;
     /**
      * KeyEvents
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * Retrieve key events for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key events
+     * @returns {Promise<KeyEventRecord[]>} A promise to the key events
      */
-    async get(pre: string): Promise<any> {
+    async get(pre) {
         const path = `/events?pre=${pre}`;
         const data = null;
         const method = 'GET';
@@ -156,59 +174,54 @@ export class KeyEvents {
         return await res.json();
     }
 }
-
 /**
  * KeyStates
  */
 export class KeyStates {
-    public client: SignifyClient;
     /**
      * KeyStates
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * Retriene the key state for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key states
+     * @returns {Promise<KeyState[]>} A promise to the key states
      */
-    async get(pre: string): Promise<any> {
+    async get(pre) {
         const path = `/states?pre=${pre}`;
         const data = null;
         const method = 'GET';
         const res = await this.client.fetch(path, method, data);
         return await res.json();
     }
-
     /**
      * Retrieve the key state for a list of identifiers
      * @async
      * @param {Array<string>} pres List of identifier prefixes
      * @returns {Promise<any>} A promise to the key states
      */
-    async list(pres: string[]): Promise<any> {
+    async list(pres) {
         const path = `/states?${pres.map((pre) => `pre=${pre}`).join('&')}`;
         const data = null;
         const method = 'GET';
         const res = await this.client.fetch(path, method, data);
         return await res.json();
     }
-
     /**
      * Query the key state of an identifier for a given sequence number or anchor
      * @async
      * @param {string} pre Identifier prefix
      * @param {number} [sn] Optional sequence number
      * @param {any} [anchor] Optional anchor
-     * @returns {Promise<any>} A promise to the long-running operation
+     * @returns {Promise<QueryOperation>} A promise to the long-running operation
      */
-    async query(pre: string, sn?: string, anchor?: any): Promise<any> {
+    async query(pre, sn, anchor) {
         const path = `/queries`;
-        const data: any = {
+        const data = {
             pre: pre,
         };
         if (sn !== undefined) {
@@ -217,9 +230,23 @@ export class KeyStates {
         if (anchor !== undefined) {
             data.anchor = anchor;
         }
-
         const method = 'POST';
         const res = await this.client.fetch(path, method, data);
         return await res.json();
     }
 }
+export class Config {
+    /**
+     * Config
+     * @param {SignifyClient} client
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    async get() {
+        const path = `/config`;
+        const method = 'GET';
+        const res = await this.client.fetch(path, method, null);
+        return await res.json();
+    }
+}

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

@@ -1,7 +1,11 @@
-import { SignifyClient } from './clienting';
-import { Dict } from '../core/core';
-import { Serder } from '../core/serder';
-import { Operation } from './coring';
+import { SignifyClient } from './clienting.ts';
+import { Dict } from '../core/core.ts';
+import { Serder } from '../core/serder.ts';
+import { ExchangeOperation, CredentialOperation, GroupOperation, DelegationOperation, WitnessOperation, DoneOperation, HabState, RegistryOperation } from '../core/keyState.ts';
+import { components } from '../../types/keria-api-schema.ts';
+export type CredentialResult = components['schemas']['Credential'];
+export type Registry = components['schemas']['Registry'];
+export type Schema = components['schemas']['Schema'];
 /** Types of credentials */
 export declare class CredentialTypes {
     static issued: string;
@@ -14,49 +18,132 @@ 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;
     anc: Serder;
     iss: Serder;
-    op: Operation;
+    op: CredentialOperation;
+}
+export interface RevokeCredentialResult {
+    anc: Serder;
+    rev: Serder;
+    op: GroupOperation | DelegationOperation | WitnessOperation | DoneOperation;
+}
+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 {
     /**
@@ -74,7 +161,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 +170,26 @@ 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 = components['schemas']['CredentialState'];
 /**
  * Credentials
  */
@@ -97,49 +204,48 @@ export declare class Credentials {
      * List credentials
      * @async
      * @param {CredentialFilter} [kargs] Optional parameters to filter the credentials
-     * @returns {Promise<any>} A promise to the list of credentials
+     * @returns {Promise<CredentialResult[]>} A promise to the list of credentials
      */
-    list(kargs?: CredentialFilter): Promise<any>;
+    list(kargs?: CredentialFilter): Promise<CredentialResult[]>;
     /**
      * Get a credential
      * @async
      * @param {string} said - SAID of the credential
      * @param {boolean} [includeCESR=false] - Optional flag export the credential in CESR format
-     * @returns {Promise<any>} A promise to the credential
+     * @returns {Promise<CredentialResult | string>} A promise to the credential
      */
-    get(said: string, includeCESR?: boolean): Promise<any>;
+    get(said: string): Promise<CredentialResult>;
+    get(said: string, includeCESR: false): Promise<CredentialResult>;
+    get(said: string, includeCESR: true): Promise<string>;
+    get(said: string, includeCESR: boolean): Promise<CredentialResult | string>;
     /**
-     * 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
+     * Creates a credential in the specified registry to be GRANTed with IPEX to the intended recipient
      */
-    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<RevokeCredentialResult>} 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;
@@ -158,7 +264,7 @@ export declare class RegistryResult {
     get regser(): any;
     get serder(): Serder;
     get sigs(): string[];
-    op(): Promise<any>;
+    op(): Promise<RegistryOperation>;
 }
 /**
  * Registries
@@ -174,9 +280,9 @@ export declare class Registries {
      * List registries
      * @async
      * @param {string} name Name or alias of the identifier
-     * @returns {Promise<any>} A promise to the list of registries
+     * @returns {Promise<Registry[]>} A promise to the list of registries
      */
-    list(name: string): Promise<any>;
+    list(name: string): Promise<Registry[]>;
     /**
      * Create a registry
      * @async
@@ -184,7 +290,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<Registry>} A promise to the registry record
+     */
+    rename(name: string, registryName: string, newName: string): Promise<Registry>;
 }
 /**
  * Schemas
@@ -200,15 +315,15 @@ export declare class Schemas {
      * Get a schema
      * @async
      * @param {string} said SAID of the schema
-     * @returns {Promise<any>} A promise to the schema
+     * @returns {Promise<Schema>} A promise to the schema
      */
-    get(said: string): Promise<any>;
+    get(said: string): Promise<Schema>;
     /**
      * List schemas
      * @async
-     * @returns {Promise<any>} A promise to the list of schemas
+     * @returns {Promise<Schema[]>} A promise to the list of schemas
      */
-    list(): Promise<any>;
+    list(): Promise<Schema[]>;
 }
 /**
  * Ipex
@@ -220,20 +335,29 @@ 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<ExchangeOperation>;
+    /**
+     * 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<ExchangeOperation>;
+    /**
+     * Create an IPEX agree EXN message
+     */
+    agree(args: IpexAgreeArgs): Promise<[Serder, string[], string]>;
+    submitAgree(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<ExchangeOperation>;
     /**
      * Create an IPEX grant EXN message
      */
     grant(args: IpexGrantArgs): Promise<[Serder, string[], string]>;
-    submitGrant(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    submitGrant(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<ExchangeOperation>;
     /**
      * 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]>;
-    submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    admit(args: IpexAdmitArgs): Promise<[Serder, string[], string]>;
+    submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<ExchangeOperation>;
 }