signify-ts 0.2.1 → 0.3.0-rc2

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

@@ -1,5 +1,14 @@
-import { SignifyClient } from './clienting';
-import { Operation } from './coring';
+import { SignifyClient } from './clienting.ts';
+import { Operation } from './coring.ts';
+export interface Contact {
+    alias: string;
+    oobi: string;
+    id: string;
+    [key: string]: unknown;
+}
+export interface ContactInfo {
+    [key: string]: unknown;
+}
 /**
  * Contacts
  */
@@ -18,29 +27,29 @@ export declare class Contacts {
      * @param {string} [filterValue] Optional field value to filter contacts
      * @returns {Promise<any>} A promise to the list of contacts
      */
-    list(group?: string, filterField?: string, filterValue?: string): Promise<any>;
+    list(group?: string, filterField?: string, filterValue?: string): Promise<Contact[]>;
     /**
      * Get a contact
      * @async
      * @param {string} pre Prefix of the contact
      * @returns {Promise<any>} A promise to the contact
      */
-    get(pre: string): Promise<any>;
+    get(pre: string): Promise<Contact>;
     /**
      * Add a contact
      * @async
-     * @param {string} pre Prefix of the contact
-     * @param {any} info Information about the contact
-     * @returns {Promise<any>} A promise to the result of the addition
+     * @param pre Prefix of the contact
+     * @param info Information about the contact
+     * @returns A promise to the result of the addition
      */
-    add(pre: string, info: any): Promise<any>;
+    add(pre: string, info: ContactInfo): Promise<Contact>;
     /**
      * Delete a contact
      * @async
      * @param {string} pre Prefix of the contact
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
-    delete(pre: string): Promise<any>;
+    delete(pre: string): Promise<void>;
     /**
      * Update a contact
      * @async
@@ -48,7 +57,10 @@ export declare class Contacts {
      * @param {any} info Updated information about the contact
      * @returns {Promise<any>} A promise to the result of the update
      */
-    update(pre: string, info: any): Promise<any>;
+    update(pre: string, info: ContactInfo): Promise<Contact>;
+}
+export interface Challenge {
+    words: string[];
 }
 /**
  * Challenges
@@ -66,27 +78,27 @@ export declare class Challenges {
      * @param {number} strength Integer representing the strength of the challenge. Typically 128 or 256
      * @returns {Promise<any>} A promise to the list of random words
      */
-    generate(strength?: number): Promise<any>;
+    generate(strength?: number): Promise<Challenge>;
     /**
      * Respond to a challenge by signing a message with the list of words
      * @async
-     * @param {string} name Name or alias of the identifier
-     * @param {string} recipient Prefix of the recipient of the response
-     * @param {Array<string>} words List of words to embed in the signed response
-     * @returns {Promise<Response>} A promise to the result of the response
+     * @param name Name or alias of the identifier
+     * @param recipient Prefix of the recipient of the response
+     * @param words List of words to embed in the signed response
+     * @returns A promise to the result of the response
      */
-    respond(name: string, recipient: string, words: string[]): Promise<Response>;
+    respond(name: string, recipient: string, words: string[]): Promise<unknown>;
     /**
      * Ask Agent to verify a given sender signed the provided words
-     * @param {string} source Prefix of the identifier that was challenged
-     * @param {Array<string>} words List of challenge words to check for
+     * @param source Prefix of the identifier that was challenged
+     * @param words List of challenge words to check for
      * @returns A promise to the long running operation
      */
     verify(source: string, words: string[]): Promise<Operation<unknown>>;
     /**
      * Mark challenge response as signed and accepted
-     * @param {string} source Prefix of the identifier that was challenged
-     * @param {string} said qb64 AID of exn message representing the signed response
+     * @param source Prefix of the identifier that was challenged
+     * @param said qb64 AID of exn message representing the signed response
      * @returns {Promise<Response>} A promise to the result
      */
     responded(source: string, said: string): Promise<Response>;

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

@@ -1,19 +1,14 @@
-import { SignifyClient } from './clienting';
-import { Operation } from './coring';
-
 /**
  * Contacts
  */
 export class Contacts {
-    client: SignifyClient;
     /**
      * Contacts
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * List contacts
      * @async
@@ -22,11 +17,7 @@ export class Contacts {
      * @param {string} [filterValue] Optional field value to filter contacts
      * @returns {Promise<any>} A promise to the list of contacts
      */
-    async list(
-        group?: string,
-        filterField?: string,
-        filterValue?: string
-    ): Promise<any> {
+    async list(group, filterField, filterValue) {
         const params = new URLSearchParams();
         if (group !== undefined) {
             params.append('group', group);
@@ -35,55 +26,47 @@ export class Contacts {
             params.append('filter_field', filterField);
             params.append('filter_value', filterValue);
         }
-
         const path = `/contacts` + '?' + params.toString();
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);
         return await res.json();
     }
-
     /**
      * Get a contact
      * @async
      * @param {string} pre Prefix of the contact
      * @returns {Promise<any>} A promise to the contact
      */
-    async get(pre: string): Promise<any> {
+    async get(pre) {
         const path = `/contacts/` + pre;
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);
         return await res.json();
     }
-
     /**
      * Add a contact
      * @async
-     * @param {string} pre Prefix of the contact
-     * @param {any} info Information about the contact
-     * @returns {Promise<any>} A promise to the result of the addition
+     * @param pre Prefix of the contact
+     * @param info Information about the contact
+     * @returns A promise to the result of the addition
      */
-    async add(pre: string, info: any): Promise<any> {
+    async add(pre, info) {
         const path = `/contacts/` + pre;
         const method = 'POST';
-
         const res = await this.client.fetch(path, method, info);
         return await res.json();
     }
-
     /**
      * Delete a contact
      * @async
      * @param {string} pre Prefix of the contact
-     * @returns {Promise<any>} A promise to the result of the deletion
+     * @returns {Promise<void>}
      */
-    async delete(pre: string): Promise<any> {
+    async delete(pre) {
         const path = `/contacts/` + pre;
         const method = 'DELETE';
-
-        const res = await this.client.fetch(path, method, null);
-        return await res.json();
+        await this.client.fetch(path, method, undefined);
     }
-
     /**
      * Update a contact
      * @async
@@ -91,92 +74,72 @@ export class Contacts {
      * @param {any} info Updated information about the contact
      * @returns {Promise<any>} A promise to the result of the update
      */
-    async update(pre: string, info: any): Promise<any> {
+    async update(pre, info) {
         const path = `/contacts/` + pre;
         const method = 'PUT';
-
         const res = await this.client.fetch(path, method, info);
         return await res.json();
     }
 }
-
 /**
  * Challenges
  */
 export class Challenges {
-    client: SignifyClient;
     /**
      * Challenges
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * Generate a random challenge word list based on BIP39
      * @async
      * @param {number} strength Integer representing the strength of the challenge. Typically 128 or 256
      * @returns {Promise<any>} A promise to the list of random words
      */
-    async generate(strength: number = 128): Promise<any> {
+    async generate(strength = 128) {
         const path = `/challenges?strength=${strength.toString()}`;
         const method = 'GET';
         const res = await this.client.fetch(path, method, null);
         return await res.json();
     }
-
     /**
      * Respond to a challenge by signing a message with the list of words
      * @async
-     * @param {string} name Name or alias of the identifier
-     * @param {string} recipient Prefix of the recipient of the response
-     * @param {Array<string>} words List of words to embed in the signed response
-     * @returns {Promise<Response>} A promise to the result of the response
+     * @param name Name or alias of the identifier
+     * @param recipient Prefix of the recipient of the response
+     * @param words List of words to embed in the signed response
+     * @returns A promise to the result of the response
      */
-    async respond(
-        name: string,
-        recipient: string,
-        words: string[]
-    ): Promise<Response> {
+    async respond(name, recipient, words) {
         const hab = await this.client.identifiers().get(name);
         const exchanges = this.client.exchanges();
-        const resp = await exchanges.send(
-            name,
-            'challenge',
-            hab,
-            '/challenge/response',
-            { words: words },
-            {},
-            [recipient]
-        );
+        const resp = await exchanges.send(name, 'challenge', hab, '/challenge/response', { words: words }, {}, [recipient]);
         return resp;
     }
-
     /**
      * Ask Agent to verify a given sender signed the provided words
-     * @param {string} source Prefix of the identifier that was challenged
-     * @param {Array<string>} words List of challenge words to check for
+     * @param source Prefix of the identifier that was challenged
+     * @param words List of challenge words to check for
      * @returns A promise to the long running operation
      */
-    async verify(source: string, words: string[]): Promise<Operation<unknown>> {
+    async verify(source, words) {
         const path = `/challenges_verify/${source}`;
         const method = 'POST';
         const data = {
             words: words,
         };
         const res = await this.client.fetch(path, method, data);
-
         return await res.json();
     }
-
     /**
      * Mark challenge response as signed and accepted
-     * @param {string} source Prefix of the identifier that was challenged
-     * @param {string} said qb64 AID of exn message representing the signed response
+     * @param source Prefix of the identifier that was challenged
+     * @param said qb64 AID of exn message representing the signed response
      * @returns {Promise<Response>} A promise to the result
      */
-    async responded(source: string, said: string): Promise<Response> {
+    async responded(source, said) {
         const path = `/challenges_verify/${source}`;
         const method = 'PUT';
         const data = {

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

@@ -1,8 +1,8 @@
-import { Tier } from '../core/salter';
-import { Serder } from '../core/serder';
-import { Verfer } from '../core/verfer';
-import { Encrypter } from '../core/encrypter';
-import { Decrypter } from '../core/decrypter';
+import { Tier } from '../core/salter.ts';
+import { Serder } from '../core/serder.ts';
+import { Verfer } from '../core/verfer.ts';
+import { Encrypter } from '../core/encrypter.ts';
+import { Decrypter } from '../core/decrypter.ts';
 /**
  * Agent is a custodial entity that can be used in conjuntion with a local Client to establish the
  * KERI "signing at the edge" semantic
@@ -24,15 +24,58 @@ export declare class Agent {
  */
 export declare class Controller {
     private bran;
+    /**
+     * The stem is the prefix for the stretched input bytes the controller's cryptographic
+     * key pairs are derived from.
+     */
     stem: string;
+    /**
+     * The security tier for the identifiers created by this Controller.
+     */
     tier: Tier;
+    /**
+     * The rotation index used during key generation by this Controller.
+     */
     ridx: number;
+    /**
+     * The salter is a cryptographic salt used to derive the controller's cryptographic key pairs
+     * and is deterministically derived from the bran and the security tier.
+     */
     salter: any;
+    /**
+     * The current signing key used to sign requests for this controller.
+     */
     signer: any;
+    /**
+     * The next signing key of which a digest is committed to in an establishment event (inception or rotation) to become the
+     * signing key after the next rotation.
+     * @private
+     */
     private nsigner;
+    /**
+     * Either the current establishment event, inception or rotation, or the interaction event used for delegation approval.
+     */
     serder: Serder;
+    /**
+     * Current public keys formatted in fully-qualified Base64.
+     * @private
+     */
     private keys;
+    /**
+     * Digests of the next public keys formatted in fully-qualified Base64.
+     */
     ndigs: string[];
+    /**
+     * Creates a Signify Controller starting at key index 0 that generates keys in
+     * memory based on the provided seed, or bran, the tier, and the rotation index.
+     *
+     * The rotation index is used as follows:
+     *
+     * @param bran
+     * @param tier
+     * @param ridx
+     * @param state
+     */
     constructor(bran: string, tier: Tier, ridx?: number, state?: any | null);
     approveDelegation(_agent: Agent): any[];
     get pre(): string;
@@ -40,7 +83,7 @@ export declare class Controller {
     get verfers(): [];
     derive(state: any): Serder;
     rotate(bran: string, aids: Array<any>): {
-        rot: import("../core/core").Dict<any>;
+        rot: import("../core/core.ts").Dict<any>;
         sigs: any[];
         sxlt: any;
         keys: Record<any, any>;