signify-ts 0.2.1 → 0.3.0-rc2

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

@@ -1,82 +1,18 @@
-import { Tier } from '../core/salter';
-import { Algos } from '../core/manager';
-import { incept, interact, reply, rotate } from '../core/eventing';
-import { b, Ilks, Serials, Versionage } from '../core/core';
-import { Tholder } from '../core/tholder';
-import { MtrDex } from '../core/matter';
-import { Serder } from '../core/serder';
-import { parseRangeHeaders } from '../core/httping';
-import { KeyManager } from '../core/keeping';
-
-/** Arguments required to create an identfier */
-export interface CreateIdentiferArgs {
-    transferable?: boolean;
-    isith?: string | number | string[];
-    nsith?: string | number | string[];
-    wits?: string[];
-    toad?: number;
-    proxy?: string;
-    delpre?: string;
-    dcode?: string;
-    data?: any;
-    algo?: Algos;
-    pre?: string;
-    states?: any[];
-    rstates?: any[];
-    prxs?: any[];
-    nxts?: any[];
-    mhab?: any;
-    keys?: any[];
-    ndigs?: any[];
-    bran?: string;
-    count?: number;
-    ncount?: number;
-    tier?: Tier;
-    extern_type?: string;
-    extern?: any;
-}
-
-/** Arguments required to rotate an identfier */
-export interface RotateIdentifierArgs {
-    transferable?: boolean;
-    nsith?: string | number | string[];
-    toad?: number;
-    cuts?: string[];
-    adds?: string[];
-    data?: Array<object>;
-    ncode?: string;
-    ncount?: number;
-    ncodes?: string[];
-    states?: any[];
-    rstates?: any[];
-}
-
-/**
- * Reducing the SignifyClient dependencies used by Identifier class
- */
-export interface IdentifierDeps {
-    fetch(
-        pathname: string,
-        method: string,
-        body: unknown,
-        headers?: Headers
-    ): Promise<Response>;
-    pidx: number;
-    manager: KeyManager | null;
-}
-
+import { Algos } from "../core/manager.js";
+import { incept, interact, reply, rotate } from "../core/eventing.js";
+import { b, Ilks, Serials, Vrsn_1_0 } from "../core/core.js";
+import { Tholder } from "../core/tholder.js";
+import { MtrDex } from "../core/matter.js";
+import { parseRangeHeaders } from "../core/httping.js";
 /** Identifier */
 export class Identifier {
-    public client: IdentifierDeps;
-
     /**
      * Identifier
      * @param {IdentifierDeps} client
      */
-    constructor(client: IdentifierDeps) {
+    constructor(client) {
         this.client = client;
     }
-
     /**
      * List managed identifiers
      * @async
@@ -84,19 +20,16 @@ export class Identifier {
      * @param {number} [end=24] End index of list of notifications, defaults to 24
      * @returns {Promise<any>} A promise to the list of managed identifiers
      */
-    async list(start: number = 0, end: number = 24): Promise<any> {
+    async list(start = 0, end = 24) {
         const extraHeaders = new Headers();
         extraHeaders.append('Range', `aids=${start}-${end}`);
-
         const path = `/identifiers`;
         const data = null;
         const method = 'GET';
         const res = await this.client.fetch(path, method, data, extraHeaders);
-
         const cr = res.headers.get('content-range');
         const range = parseRangeHeaders(cr, 'aids');
         const aids = await res.json();
-
         return {
             start: range.start,
             end: range.end,
@@ -104,21 +37,32 @@ export class Identifier {
             aids: aids,
         };
     }
-
     /**
      * Get information for a managed identifier
      * @async
-     * @param {string} name Name or alias of the identifier
-     * @returns {Promise<any>} A promise to the identifier information
+     * @param {string} name Prefix or alias of the identifier
+     * @returns {Promise<HabState>} A promise to the identifier information
      */
-    async get(name: string): Promise<any> {
-        const path = `/identifiers/${name}`;
+    async get(name) {
+        const path = `/identifiers/${encodeURIComponent(name)}`;
         const data = null;
         const method = 'GET';
         const res = await this.client.fetch(path, method, data);
         return await res.json();
     }
-
+    /**
+     * Update managed identifier
+     * @async
+     * @param {string} name Prefix or alias of the identifier
+     * @param {IdentifierInfo} info Information to update for the given identifier
+     * @returns {Promise<HabState>} A promise to the identifier information after updating
+     */
+    async update(name, info) {
+        const path = `/identifiers/${name}`;
+        const method = 'PUT';
+        const res = await this.client.fetch(path, method, info);
+        return await res.json();
+    }
     /**
      * Create a managed identifier
      * @async
@@ -126,18 +70,15 @@ export class Identifier {
      * @param {CreateIdentiferArgs} [kargs] Optional parameters to create the identifier
      * @returns {EventResult} The inception result
      */
-    async create(
-        name: string,
-        kargs: CreateIdentiferArgs = {}
-    ): Promise<EventResult> {
+    async create(name, kargs = {}) {
+        var _a, _b, _c, _d, _e, _f;
         const algo = kargs.algo == undefined ? Algos.salty : kargs.algo;
-
-        const transferable = kargs.transferable ?? true;
-        const isith = kargs.isith ?? '1';
-        const nsith = kargs.nsith ?? '1';
-        let wits = kargs.wits ?? [];
-        const toad = kargs.toad ?? 0;
-        const dcode = kargs.dcode ?? MtrDex.Blake3_256;
+        const transferable = (_a = kargs.transferable) !== null && _a !== void 0 ? _a : true;
+        const isith = (_b = kargs.isith) !== null && _b !== void 0 ? _b : '1';
+        let nsith = (_c = kargs.nsith) !== null && _c !== void 0 ? _c : '1';
+        let wits = (_d = kargs.wits) !== null && _d !== void 0 ? _d : [];
+        const toad = (_e = kargs.toad) !== null && _e !== void 0 ? _e : 0;
+        let dcode = (_f = kargs.dcode) !== null && _f !== void 0 ? _f : MtrDex.Blake3_256;
         const proxy = kargs.proxy;
         const delpre = kargs.delpre;
         const data = kargs.data != undefined ? [kargs.data] : [];
@@ -151,11 +92,15 @@ export class Identifier {
         const _ndigs = kargs.ndigs;
         const bran = kargs.bran;
         const count = kargs.count;
-        const ncount = kargs.ncount;
+        let ncount = kargs.ncount;
         const tier = kargs.tier;
         const extern_type = kargs.extern_type;
         const extern = kargs.extern;
-
+        if (!transferable) {
+            ncount = 0;
+            nsith = 0;
+            dcode = MtrDex.Ed25519N;
+        }
         const xargs = {
             transferable: transferable,
             isith: isith,
@@ -182,14 +127,13 @@ export class Identifier {
             extern_type: extern_type,
             extern: extern,
         };
-
-        const keeper = this.client.manager!.new(algo, this.client.pidx, xargs);
-        const [keys, ndigs] = await keeper!.incept(transferable);
+        const keeper = this.client.manager.new(algo, this.client.pidx, xargs);
+        const [keys, ndigs] = await keeper.incept(transferable);
         wits = wits !== undefined ? wits : [];
-        let serder: Serder | undefined = undefined;
+        let serder = undefined;
         if (delpre == undefined) {
             serder = incept({
-                keys: keys!,
+                keys: keys,
                 isith: isith,
                 ndigs: ndigs,
                 nsith: nsith,
@@ -197,14 +141,15 @@ export class Identifier {
                 wits: wits,
                 cnfg: [],
                 data: data,
-                version: Versionage,
+                version: Vrsn_1_0,
                 kind: Serials.JSON,
                 code: dcode,
                 intive: false,
             });
-        } else {
+        }
+        else {
             serder = incept({
-                keys: keys!,
+                keys: keys,
                 isith: isith,
                 ndigs: ndigs,
                 nsith: nsith,
@@ -212,55 +157,50 @@ export class Identifier {
                 wits: wits,
                 cnfg: [],
                 data: data,
-                version: Versionage,
+                version: Vrsn_1_0,
                 kind: Serials.JSON,
                 code: dcode,
                 intive: false,
                 delpre: delpre,
             });
         }
-
-        const sigs = await keeper!.sign(b(serder.raw));
-        const jsondata: any = {
+        const sigs = await keeper.sign(b(serder.raw));
+        const jsondata = {
             name: name,
-            icp: serder.ked,
+            icp: serder.sad,
             sigs: sigs,
             proxy: proxy,
-            smids:
-                states != undefined
-                    ? states.map((state) => state.i)
-                    : undefined,
-            rmids:
-                rstates != undefined
-                    ? rstates.map((state) => state.i)
-                    : undefined,
+            smids: states != undefined
+                ? states.map((state) => state.i)
+                : undefined,
+            rmids: rstates != undefined
+                ? rstates.map((state) => state.i)
+                : undefined,
         };
         jsondata[algo] = keeper.params();
-
         this.client.pidx = this.client.pidx + 1;
-        const res = this.client.fetch('/identifiers', 'POST', jsondata);
+        const res = await this.client.fetch('/identifiers', 'POST', jsondata);
         return new EventResult(serder, sigs, res);
     }
-
     /**
      * Generate an interaction event in a managed identifier
      * @async
-     * @param {string} name Name or alias of the identifier
+     * @param {string} name Prefix or alias of the identifier
      * @param {any} [data] Option data to be anchored in the interaction event
      * @returns {Promise<EventResult>} A promise to the interaction event result
      */
-    async interact(name: string, data?: any): Promise<EventResult> {
+    async interact(name, data) {
+        const { serder, sigs, jsondata } = await this.createInteract(name, data);
+        const res = await this.client.fetch('/identifiers/' + name + '/events', 'POST', jsondata);
+        return new EventResult(serder, sigs, res);
+    }
+    async createInteract(name, data) {
         const hab = await this.get(name);
-        const pre: string = hab.prefix;
-
+        const pre = hab.prefix;
         const state = hab.state;
-        const sn = Number(state.s);
+        const sn = parseInt(state.s, 16);
         const dig = state.d;
-
-        data = Array.isArray(data) ? data : [data];
-
         data = Array.isArray(data) ? data : [data];
-
         const serder = interact({
             pre: pre,
             sn: sn + 1,
@@ -269,81 +209,56 @@ export class Identifier {
             version: undefined,
             kind: undefined,
         });
-        const keeper = this.client!.manager!.get(hab);
+        const keeper = this.client.manager.get(hab);
         const sigs = await keeper.sign(b(serder.raw));
-
-        const jsondata: any = {
-            ixn: serder.ked,
+        const jsondata = {
+            ixn: serder.sad,
             sigs: sigs,
         };
         jsondata[keeper.algo] = keeper.params();
-
-        const res = await this.client.fetch(
-            '/identifiers/' + name + '?type=ixn',
-            'PUT',
-            jsondata
-        );
-        return new EventResult(serder, sigs, res);
+        return { serder, sigs, jsondata };
     }
-
     /**
      * Generate a rotation event in a managed identifier
      * @param {string} name Name or alias of the identifier
      * @param {RotateIdentifierArgs} [kargs] Optional parameters requiered to generate the rotation event
      * @returns {Promise<EventResult>} A promise to the rotation event result
      */
-    async rotate(
-        name: string,
-        kargs: RotateIdentifierArgs = {}
-    ): Promise<EventResult> {
-        const transferable = kargs.transferable ?? true;
-        const ncode = kargs.ncode ?? MtrDex.Ed25519_Seed;
-        const ncount = kargs.ncount ?? 1;
-
+    async rotate(name, kargs = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const transferable = (_a = kargs.transferable) !== null && _a !== void 0 ? _a : true;
+        const ncode = (_b = kargs.ncode) !== null && _b !== void 0 ? _b : MtrDex.Ed25519_Seed;
+        const ncount = (_c = kargs.ncount) !== null && _c !== void 0 ? _c : 1;
         const hab = await this.get(name);
         const pre = hab.prefix;
         const delegated = hab.state.di !== '';
-
         const state = hab.state;
         const count = state.k.length;
         const dig = state.d;
-        const ridx = Number(state.s) + 1;
+        const ridx = parseInt(state.s, 16) + 1;
         const wits = state.b;
         let isith = state.nt;
-
-        let nsith = kargs.nsith ?? isith;
-
+        let nsith = (_d = kargs.nsith) !== null && _d !== void 0 ? _d : isith;
         // if isith is None:  # compute default from newly rotated verfers above
         if (isith == undefined)
             isith = `${Math.max(1, Math.ceil(count / 2)).toString(16)}`;
-
         // if nsith is None:  # compute default from newly rotated digers above
         if (nsith == undefined)
             nsith = `${Math.max(1, Math.ceil(ncount / 2)).toString(16)}`;
-
         const cst = new Tholder({ sith: isith }).sith; // current signing threshold
         const nst = new Tholder({ sith: nsith }).sith; // next signing threshold
-
         // Regenerate next keys to sign rotation event
-        const keeper = this.client.manager!.get(hab);
+        const keeper = this.client.manager.get(hab);
         // Create new keys for next digests
-        const ncodes = kargs.ncodes ?? new Array(ncount).fill(ncode);
-
+        const ncodes = (_e = kargs.ncodes) !== null && _e !== void 0 ? _e : new Array(ncount).fill(ncode);
         const states = kargs.states == undefined ? [] : kargs.states;
         const rstates = kargs.rstates == undefined ? [] : kargs.rstates;
-        const [keys, ndigs] = await keeper!.rotate(
-            ncodes,
-            transferable,
-            states,
-            rstates
-        );
-
-        const cuts = kargs.cuts ?? [];
-        const adds = kargs.adds ?? [];
+        const [keys, ndigs] = await keeper.rotate(ncodes, transferable, states, rstates);
+        const cuts = (_f = kargs.cuts) !== null && _f !== void 0 ? _f : [];
+        const adds = (_g = kargs.adds) !== null && _g !== void 0 ? _g : [];
         const data = kargs.data != undefined ? [kargs.data] : [];
         const toad = kargs.toad;
         const ilk = delegated ? Ilks.drt : Ilks.rot;
-
         const serder = rotate({
             pre: pre,
             ilk: ilk,
@@ -359,31 +274,21 @@ export class Identifier {
             adds: adds,
             data: data,
         });
-
         const sigs = await keeper.sign(b(serder.raw));
-
-        const jsondata: any = {
-            rot: serder.ked,
+        const jsondata = {
+            rot: serder.sad,
             sigs: sigs,
-            smids:
-                states != undefined
-                    ? states.map((state) => state.i)
-                    : undefined,
-            rmids:
-                rstates != undefined
-                    ? rstates.map((state) => state.i)
-                    : undefined,
+            smids: states != undefined
+                ? states.map((state) => state.i)
+                : undefined,
+            rmids: rstates != undefined
+                ? rstates.map((state) => state.i)
+                : undefined,
         };
         jsondata[keeper.algo] = keeper.params();
-
-        const res = await this.client.fetch(
-            '/identifiers/' + name,
-            'PUT',
-            jsondata
-        );
+        const res = await this.client.fetch('/identifiers/' + name + '/events', 'POST', jsondata);
         return new EventResult(serder, sigs, res);
     }
-
     /**
      * Authorize an endpoint provider in a given role for a managed identifier
      * @remarks
@@ -395,32 +300,19 @@ export class Identifier {
      * @param {string} [stamp=now] Optional date-time-stamp RFC-3339 profile of iso8601 datetime. Now is the default if not provided
      * @returns {Promise<EventResult>} A promise to the result of the authorization
      */
-    async addEndRole(
-        name: string,
-        role: string,
-        eid?: string,
-        stamp?: string
-    ): Promise<EventResult> {
+    async addEndRole(name, role, eid, stamp) {
         const hab = await this.get(name);
         const pre = hab.prefix;
-
         const rpy = this.makeEndRole(pre, role, eid, stamp);
-        const keeper = this.client.manager!.get(hab);
+        const keeper = this.client.manager.get(hab);
         const sigs = await keeper.sign(b(rpy.raw));
-
         const jsondata = {
-            rpy: rpy.ked,
+            rpy: rpy.sad,
             sigs: sigs,
         };
-
-        const res = this.client.fetch(
-            '/identifiers/' + name + '/endroles',
-            'POST',
-            jsondata
-        );
+        const res = await this.client.fetch('/identifiers/' + name + '/endroles', 'POST', jsondata);
         return new EventResult(rpy, sigs, res);
     }
-
     /**
      * Generate an /end/role/add reply message
      * @param {string} pre Prefix of the identifier
@@ -429,13 +321,8 @@ export class Identifier {
      * @param {string} [stamp=now] Optional date-time-stamp RFC-3339 profile of iso8601 datetime. Now is the default if not provided
      * @returns {Serder} The reply message
      */
-    private makeEndRole(
-        pre: string,
-        role: string,
-        eid?: string,
-        stamp?: string
-    ): Serder {
-        const data: any = {
+    makeEndRole(pre, role, eid, stamp) {
+        const data = {
             cid: pre,
             role: role,
         };
@@ -445,49 +332,31 @@ export class Identifier {
         const route = '/end/role/add';
         return reply(route, data, stamp, undefined, Serials.JSON);
     }
-
     /**
      * Get the members of a group identifier
      * @async
      * @param {string} name - Name or alias of the identifier
      * @returns {Promise<any>} - A promise to the list of members
      */
-    async members(name: string): Promise<any> {
-        const res = await this.client.fetch(
-            '/identifiers/' + name + '/members',
-            'GET',
-            undefined
-        );
+    async members(name) {
+        const res = await this.client.fetch('/identifiers/' + name + '/members', 'GET', undefined);
         return await res.json();
     }
 }
-
 /** Event Result */
 export class EventResult {
-    private readonly _serder: Serder;
-    private readonly _sigs: string[];
-    private readonly promise: Promise<Response> | Response;
-
-    constructor(
-        serder: Serder,
-        sigs: string[],
-        promise: Promise<Response> | Response
-    ) {
+    constructor(serder, sigs, response) {
         this._serder = serder;
         this._sigs = sigs;
-        this.promise = promise;
+        this.response = response;
     }
-
     get serder() {
         return this._serder;
     }
-
     get sigs() {
         return this._sigs;
     }
-
-    async op(): Promise<any> {
-        const res = await this.promise;
-        return await res.json();
+    async op() {
+        return await this.response.json();
     }
 }

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

@@ -1,15 +1,16 @@
-import { Agent, Controller } from './controller';
-import { Tier } from '../core/salter';
-import { Authenticater } from '../core/authing';
-import { ExternalModule, KeyManager } from '../core/keeping';
-import { Identifier } from './aiding';
-import { Contacts, Challenges } from './contacting';
-import { Oobis, Operations, KeyEvents, KeyStates } from './coring';
-import { Credentials, Ipex, Registries, Schemas } from './credentialing';
-import { Notifications } from './notifying';
-import { Escrows } from './escrowing';
-import { Groups } from './grouping';
-import { Exchanges } from './exchanging';
+import { Authenticater } from '../core/authing.ts';
+import { ExternalModule, IdentifierManagerFactory } from '../core/keeping.ts';
+import { Tier } from '../core/salter.ts';
+import { Identifier } from './aiding.ts';
+import { Contacts, Challenges } from './contacting.ts';
+import { Agent, Controller } from './controller.ts';
+import { Oobis, Operations, KeyEvents, KeyStates, Config } from './coring.ts';
+import { Credentials, Ipex, Registries, Schemas } from './credentialing.ts';
+import { Delegations } from './delegating.ts';
+import { Escrows } from './escrowing.ts';
+import { Exchanges } from './exchanging.ts';
+import { Groups } from './grouping.ts';
+import { Notifications } from './notifying.ts';
 declare class State {
     agent: any | null;
     controller: any | null;
@@ -17,7 +18,10 @@ declare class State {
     pidx: number;
     constructor();
 }
-/** SignifyClient */
+/**
+ * An in-memory key manager that can connect to a KERIA Agent and use it to
+ * receive messages and act as a proxy for multi-signature operations and delegation operations.
+ */
 export declare class SignifyClient {
     controller: Controller;
     url: string;
@@ -25,10 +29,27 @@ export declare class SignifyClient {
     pidx: number;
     agent: Agent | null;
     authn: Authenticater | null;
-    manager: KeyManager | null;
+    manager: IdentifierManagerFactory | null;
     tier: Tier;
     bootUrl: string;
     exteralModules: ExternalModule[];
+    private _identifiers;
+    private _operations;
+    private _keyEvents;
+    private _keyStates;
+    private _oobis;
+    private _config;
+    private _delegations;
+    private _exchanges;
+    private _groups;
+    private _escrows;
+    private _credentials;
+    private _registries;
+    private _ipex;
+    private _notifications;
+    private _contacts;
+    private _challenges;
+    private _schemas;
     /**
      * SignifyClient constructor
      * @param {string} url KERIA admin interface URL
@@ -66,16 +87,20 @@ export declare class SignifyClient {
      */
     fetch(path: string, method: string, data: any, extraHeaders?: Headers): Promise<Response>;
     /**
-     * Fetch a resource from from an external URL with headers signed by an AID
+     * Create a Signed Request to fetch a resource from an external URL with headers signed by an AID
      * @async
-     * @param {string} url URL of the resource
-     * @param {string} path Path to the resource
-     * @param {string} method HTTP method
-     * @param {any} data Data to be sent in the body of the resource
      * @param {string} aidName Name or alias of the AID to be used for signing
-     * @returns {Promise<Response>} A promise to the result of the fetch
-     */
-    signedFetch(url: string, path: string, method: string, data: any, aidName: string): Promise<Response>;
+     * @param {string} url URL of the requested resource
+     * @param {RequestInit} req Request options should include:
+     *     - method: HTTP method
+     *     - data Data to be sent in the body of the resource.
+     *              If the data is a CESR JSON string then you should also set contentType to 'application/json+cesr'
+     *              If the data is a FormData object then you should not set the contentType and the browser will set it to 'multipart/form-data'
+     *              If the data is an object then you should use JSON.stringify to convert it to a string and set the contentType to 'application/json'
+     *     - contentType Content type of the request.
+     * @returns {Promise<Request>} A promise to the created Request
+     */
+    createSignedRequest(aidName: string, url: string, req: RequestInit): Promise<Request>;
     /**
      * Approve the delegation of the client AID to the KERIA agent
      * @async
@@ -178,5 +203,15 @@ export declare class SignifyClient {
      * @returns {Exchanges}
      */
     exchanges(): Exchanges;
+    /**
+     * Get delegations resource
+     * @returns {Delegations}
+     */
+    delegations(): Delegations;
+    /**
+     * Get agent config resource
+     * @returns {Config}
+     */
+    config(): Config;
 }
 export {};