signify-ts 0.2.0 → 0.3.0-dev.e31e78d

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

@@ -1,31 +1,23 @@
-import { SaltyCreator } from '../core/manager';
-import { Salter, Tier } from '../core/salter';
-import { MtrDex } from '../core/matter';
-import { Diger } from '../core/diger';
-import { incept, rotate, interact } from '../core/eventing';
-import { Serder } from '../core/serder';
-import { Tholder } from '../core/tholder';
-import { Ilks, b, Serials, Versionage } from '../core/core';
-import { Verfer } from '../core/verfer';
-import { Encrypter } from '../core/encrypter';
-import { Decrypter } from '../core/decrypter';
-import { Cipher } from '../core/cipher';
-import { Seqner } from '../core/seqner';
-import { CesrNumber } from '../core/number';
-
+import { SaltyCreator } from "../core/manager.js";
+import { Salter } from "../core/salter.js";
+import { MtrDex } from "../core/matter.js";
+import { Diger } from "../core/diger.js";
+import { incept, rotate, interact } from "../core/eventing.js";
+import { Serder } from "../core/serder.js";
+import { Tholder } from "../core/tholder.js";
+import { Ilks, b, Serials, Vrsn_1_0 } from "../core/core.js";
+import { Verfer } from "../core/verfer.js";
+import { Encrypter } from "../core/encrypter.js";
+import { Decrypter } from "../core/decrypter.js";
+import { Cipher } from "../core/cipher.js";
+import { Seqner } from "../core/seqner.js";
+import { CesrNumber } from "../core/number.js";
 /**
  * Agent is a custodial entity that can be used in conjuntion with a local Client to establish the
  * KERI "signing at the edge" semantic
  */
 export class Agent {
-    pre: string;
-    anchor: string;
-    verfer: Verfer | null;
-    state: any | null;
-    sn: number | undefined;
-    said: string | undefined;
-
-    constructor(agent: any) {
+    constructor(agent) {
         this.pre = '';
         this.anchor = '';
         this.verfer = null;
@@ -34,121 +26,87 @@ export class Agent {
         this.said = '';
         this.parse(agent);
     }
-
-    private parse(agent: Agent) {
+    parse(agent) {
         const [state, verfer] = this.event(agent);
-
-        this.sn = new CesrNumber({}, undefined, state['s']).num;
+        this.sn = new CesrNumber({}, state['s']).num;
         this.said = state['d'];
-
         if (state['et'] !== Ilks.dip) {
             throw new Error(`invalid inception event type ${state['et']}`);
         }
-
         this.pre = state['i'];
         if (!state['di']) {
             throw new Error('no anchor to controller AID');
         }
-
         this.anchor = state['di'];
-
         this.verfer = verfer;
         this.state = state;
     }
-
-    private event(evt: any): [any, Verfer, Diger] {
+    event(evt) {
         if (evt['k'].length !== 1) {
             throw new Error(`agent inception event can only have one key`);
         }
-
         const verfer = new Verfer({ qb64: evt['k'][0] });
-
         if (evt['n'].length !== 1) {
             throw new Error(`agent inception event can only have one next key`);
         }
-
         const diger = new Diger({ qb64: evt['n'][0] });
-
         const tholder = new Tholder({ sith: evt['kt'] });
         if (tholder.num !== 1) {
             throw new Error(`invalid threshold ${tholder.num}, must be 1`);
         }
-
         const ntholder = new Tholder({ sith: evt['nt'] });
         if (ntholder.num !== 1) {
-            throw new Error(
-                `invalid next threshold ${ntholder.num}, must be 1`
-            );
+            throw new Error(`invalid next threshold ${ntholder.num}, must be 1`);
         }
         return [evt, verfer, diger];
     }
 }
-
 /**
  * Controller is responsible for managing signing keys for the client and agent.  The client
  * signing key represents the Account for the client on the agent
  */
 export class Controller {
-    private bran: string;
-    public stem: string;
-    public tier: Tier;
-    public ridx: number;
-    public salter: any;
-    public signer: any;
-    private nsigner: any;
-    public serder: Serder;
-    private keys: string[];
-    public ndigs: string[];
-
-    constructor(
-        bran: string,
-        tier: Tier,
-        ridx: number = 0,
-        state: any | null = null
-    ) {
+    /**
+     * 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, tier, ridx = 0, state = null) {
         this.bran = MtrDex.Salt_128 + 'A' + bran.substring(0, 21); // qb64 salt for seed
         this.stem = 'signify:controller';
         this.tier = tier;
         this.ridx = ridx;
-
+        const codes = undefined; // Defines the types of seeds that the SaltyCreator will create. Defaults to undefined.
+        const keyCount = 1; // The number of keys to create. Defaults to 1.
+        const transferable = true; // Whether the keys are transferable. Defaults to true.
+        const code = MtrDex.Ed25519_Seed; // The type  cryptographic seed to create by default when not overiddeen by "codes".
+        const pidx = 0; // The index of this identifier prefix of all managed identifiers created for this SignifyClient Controller. Defaults to 0.
+        const kidx = 0; // The overall starting key index for the first key this rotation set of keys. This is not a local index to this set of keys but an index in the overall set of keys for all keys in this sequence.
+        // Defaults to 0. Multiply rotation index (ridx) times key count to get the overall key index.
         this.salter = new Salter({ qb64: this.bran, tier: this.tier });
-
-        const creator = new SaltyCreator(
-            this.salter.qb64,
-            this.tier,
-            this.stem
-        );
-
+        const creator = new SaltyCreator(this.salter.qb64, this.tier, this.stem);
+        // Creates the first key pair used to sign the inception event.
+        // noinspection UnnecessaryLocalVariableJS
+        const initialKeyIndex = ridx; // will be zero for inception
         this.signer = creator
-            .create(
-                undefined,
-                1,
-                MtrDex.Ed25519_Seed,
-                true,
-                0,
-                this.ridx,
-                0,
-                false
-            )
-            .signers.pop();
+            .create(codes, keyCount, code, transferable, pidx, initialKeyIndex, kidx)
+            .signers.pop(); // assumes only one key pair is created because keyCount is 1
+        // Creates the second key pair which a digest of the public key is committed to in the inception event.
+        const nextKeyIndex = ridx + 1;
         this.nsigner = creator
-            .create(
-                undefined,
-                1,
-                MtrDex.Ed25519_Seed,
-                true,
-                0,
-                this.ridx + 1,
-                0,
-                false
-            )
-            .signers.pop();
+            .create(codes, keyCount, code, transferable, pidx, nextKeyIndex, kidx)
+            .signers.pop(); // assumes only one key pair is created because keyCount is 1
         this.keys = [this.signer.verfer.qb64];
         this.ndigs = [
             new Diger({ code: MtrDex.Blake3_256 }, this.nsigner.verfer.qb64b)
                 .qb64,
         ];
-
         if (state == null || state['ee']['s'] == 0) {
             this.serder = incept({
                 keys: this.keys,
@@ -159,40 +117,36 @@ export class Controller {
                 toad: '0',
                 wits: [],
             });
-        } else {
+        }
+        else {
             this.serder = new Serder(state['ee']);
         }
     }
-
-    approveDelegation(_agent: Agent) {
+    approveDelegation(_agent) {
         const seqner = new Seqner({ sn: _agent.sn });
         const anchor = { i: _agent.pre, s: seqner.snh, d: _agent.said };
-        const sn = new CesrNumber({}, undefined, this.serder.ked['s']).num + 1;
+        const sn = new CesrNumber({}, this.serder.sad['s']).num + 1;
         this.serder = interact({
             pre: this.serder.pre,
-            dig: this.serder.ked['d'],
+            dig: this.serder.sad['d'],
             sn: sn,
             data: [anchor],
-            version: Versionage,
+            version: Vrsn_1_0,
             kind: Serials.JSON,
         });
         return [this.signer.sign(this.serder.raw, 0).qb64];
     }
-
-    get pre(): string {
+    get pre() {
         return this.serder.pre;
     }
-
     get event() {
         const siger = this.signer.sign(this.serder.raw, 0);
         return [this.serder, siger];
     }
-
-    get verfers(): [] {
+    get verfers() {
         return this.signer.verfer();
     }
-
-    derive(state: any) {
+    derive(state) {
         if (state != undefined && state['ee']['s'] === '0') {
             return incept({
                 keys: this.keys,
@@ -203,124 +157,70 @@ export class Controller {
                 toad: '0',
                 wits: [],
             });
-        } else {
-            return new Serder({ ked: state.controller['ee'] });
+        }
+        else {
+            return new Serder({ sad: state.controller['ee'] });
         }
     }
-
-    rotate(bran: string, aids: Array<any>) {
+    rotate(bran, aids) {
         const nbran = MtrDex.Salt_128 + 'A' + bran.substring(0, 21); // qb64 salt for seed
         const nsalter = new Salter({ qb64: nbran, tier: this.tier });
         const nsigner = this.salter.signer(undefined, false);
-
-        const creator = new SaltyCreator(
-            this.salter.qb64,
-            this.tier,
-            this.stem
-        );
+        const creator = new SaltyCreator(this.salter.qb64, this.tier, this.stem);
         const signer = creator
-            .create(
-                undefined,
-                1,
-                MtrDex.Ed25519_Seed,
-                true,
-                0,
-                this.ridx + 1,
-                0,
-                false
-            )
+            .create(undefined, 1, MtrDex.Ed25519_Seed, true, 0, this.ridx + 1, 0, false)
             .signers.pop();
-
         const ncreator = new SaltyCreator(nsalter.qb64, this.tier, this.stem);
         this.signer = ncreator
-            .create(
-                undefined,
-                1,
-                MtrDex.Ed25519_Seed,
-                true,
-                0,
-                this.ridx,
-                0,
-                false
-            )
+            .create(undefined, 1, MtrDex.Ed25519_Seed, true, 0, this.ridx, 0, false)
             .signers.pop();
         this.nsigner = ncreator
-            .create(
-                undefined,
-                1,
-                MtrDex.Ed25519_Seed,
-                true,
-                0,
-                this.ridx + 1,
-                0,
-                false
-            )
+            .create(undefined, 1, MtrDex.Ed25519_Seed, true, 0, this.ridx + 1, 0, false)
             .signers.pop();
-
-        this.keys = [this.signer.verfer.qb64, signer?.verfer.qb64];
+        this.keys = [this.signer.verfer.qb64, signer === null || signer === void 0 ? void 0 : signer.verfer.qb64];
         this.ndigs = [new Diger({}, this.nsigner.verfer.qb64b).qb64];
-
         const rot = rotate({
             pre: this.pre,
             keys: this.keys,
-            dig: this.serder.ked['d'],
+            dig: this.serder.sad['d'],
             isith: ['1', '0'],
             nsith: '1',
             ndigs: this.ndigs,
         });
-
         const sigs = [
-            signer?.sign(b(rot.raw), 1, false, 0).qb64,
+            signer === null || signer === void 0 ? void 0 : signer.sign(b(rot.raw), 1, false, 0).qb64,
             this.signer.sign(rot.raw, 0).qb64,
         ];
         const encrypter = new Encrypter({}, b(nsigner.verfer.qb64));
         const decrypter = new Decrypter({}, nsigner.qb64b);
         const sxlt = encrypter.encrypt(b(this.bran)).qb64;
-
-        const keys: Record<any, any> = {};
-
+        const keys = {};
         for (const aid of aids) {
-            const pre: string = aid['prefix'] as string;
+            const pre = aid['prefix'];
             if ('salty' in aid) {
-                const salty: any = aid['salty'];
+                const salty = aid['salty'];
                 const cipher = new Cipher({ qb64: salty['sxlt'] });
                 const dnxt = decrypter.decrypt(null, cipher).qb64;
-
                 // Now we have the AID salt, use it to verify against the current public keys
-                const acreator = new SaltyCreator(
-                    dnxt,
-                    salty['tier'],
-                    salty['stem']
-                );
-                const signers = acreator.create(
-                    salty['icodes'],
-                    undefined,
-                    MtrDex.Ed25519_Seed,
-                    salty['transferable'],
-                    salty['pidx'],
-                    0,
-                    salty['kidx'],
-                    false
-                );
+                const acreator = new SaltyCreator(dnxt, salty['tier'], salty['stem']);
+                const signers = acreator.create(salty['icodes'], undefined, MtrDex.Ed25519_Seed, salty['transferable'], salty['pidx'], 0, salty['kidx'], false);
                 const _signers = [];
                 for (const signer of signers.signers) {
                     _signers.push(signer.verfer.qb64);
                 }
                 const pubs = aid['state']['k'];
-
                 if (pubs.join(',') != _signers.join(',')) {
                     throw new Error('Invalid Salty AID');
                 }
-
                 const asxlt = encrypter.encrypt(b(dnxt)).qb64;
                 keys[pre] = {
                     sxlt: asxlt,
                 };
-            } else if ('randy' in aid) {
+            }
+            else if ('randy' in aid) {
                 const randy = aid['randy'];
                 const prxs = randy['prxs'];
                 const nxts = randy['nxts'];
-
                 const nprxs = [];
                 const signers = [];
                 for (const prx of prxs) {
@@ -334,37 +234,31 @@ export class Controller {
                 for (const signer of signers) {
                     _signers.push(signer.verfer.qb64);
                 }
-
                 if (pubs.join(',') != _signers.join(',')) {
-                    throw new Error(
-                        `unable to rotate, validation of encrypted public keys ${pubs} failed`
-                    );
+                    throw new Error(`unable to rotate, validation of encrypted public keys ${pubs} failed`);
                 }
-
                 const nnxts = [];
                 for (const nxt of nxts) {
                     nnxts.push(this.recrypt(nxt, decrypter, encrypter));
                 }
-
                 keys[pre] = {
                     prxs: nprxs,
                     nxts: nnxts,
                 };
-            } else {
+            }
+            else {
                 throw new Error('invalid aid type ');
             }
         }
-
         const data = {
-            rot: rot.ked,
+            rot: rot.sad,
             sigs: sigs,
             sxlt: sxlt,
             keys: keys,
         };
         return data;
     }
-
-    recrypt(enc: string, decrypter: Decrypter, encrypter: Encrypter) {
+    recrypt(enc, decrypter, encrypter) {
         const cipher = new Cipher({ qb64: enc });
         const dnxt = decrypter.decrypt(null, cipher).qb64;
         return encrypter.encrypt(b(dnxt)).qb64;

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

@@ -1,4 +1,10 @@
-import { SignifyClient } from './clienting';
+import { SignifyClient } from './clienting.ts';
+import { components } from '../../types/keria-api-schema.ts';
+import { OOBIOperation, QueryOperation, EndRoleOperation, WitnessOperation, DelegationOperation, RegistryOperation, LocSchemeOperation, ChallengeOperation, ExchangeOperation, SubmitOperation, DoneOperation, CredentialOperation, GroupOperation, DelegatorOperation, CompletedOOBIOperation, CompletedQueryOperation, CompletedEndRoleOperation, CompletedWitnessOperation, CompletedDelegationOperation, CompletedRegistryOperation, CompletedLocSchemeOperation, CompletedChallengeOperation, CompletedExchangeOperation, CompletedSubmitOperation, CompletedDoneOperation, CompletedCredentialOperation, CompletedGroupOperation, CompletedDelegatorOperation, CompletedOperation } from '../core/keyState.ts';
+type OOBI = components['schemas']['OOBI'];
+type KeyState = components['schemas']['KeyStateRecord'];
+type KeyEventRecord = components['schemas']['KeyEventRecord'];
+type AgentConfig = components['schemas']['AgentConfig'];
 export declare function randomPasscode(): string;
 export declare function randomNonce(): string;
 export declare class Oobis {
@@ -12,27 +18,21 @@ export declare class Oobis {
      * 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)
      */
-    get(name: string, role?: string): Promise<any>;
+    get(name: string, role?: string): Promise<OOBI>;
     /**
      * 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
      */
-    resolve(oobi: string, alias?: string): Promise<any>;
+    resolve(oobi: string, alias?: string): Promise<OOBIOperation>;
 }
-export interface Operation<T = unknown> {
-    name: string;
-    metadata?: {
-        depends?: Operation;
-        [property: string]: any;
-    };
-    done?: boolean;
-    error?: any;
-    response?: T;
+export type Operation = OOBIOperation | QueryOperation | EndRoleOperation | WitnessOperation | DelegationOperation | RegistryOperation | LocSchemeOperation | ChallengeOperation | ExchangeOperation | SubmitOperation | DoneOperation | CredentialOperation | GroupOperation | DelegatorOperation;
+export interface OperationsDeps {
+    fetch(pathname: string, method: string, body: unknown, headers?: Headers): Promise<Response>;
 }
 /**
  * Operations
@@ -40,32 +40,131 @@ export interface Operation<T = unknown> {
  * Operations represent the status and result of long running tasks performed by KERIA agent
  */
 export declare class Operations {
-    client: SignifyClient;
+    client: OperationsDeps;
     /**
      * Operations
      * @param {SignifyClient} client
      */
-    constructor(client: SignifyClient);
+    constructor(client: OperationsDeps);
+    private hasDepends;
+    /**
+     * Check if operation failed and throw error with details
+     * @throws {Error} If operation has an error
+     */
+    private throwIfFailed;
     /**
      * Get operation status
      * @async
      * @param {string} name Name of the operation
      * @returns {Promise<Operation>} A promise to the status of the operation
      */
-    get<T = unknown>(name: string): Promise<Operation<T>>;
+    get(name: string): Promise<Operation>;
     /**
      * List operations
      * @async
      * @param {string} type Select operations by type
      * @returns {Promise<Operation[]>} A list of operations
      */
-    list(type?: string): Promise<Operation<any>[]>;
+    list(type?: string): Promise<Operation[]>;
     /**
      * Delete operation
      * @async
      * @param {string} name Name of the operation
      */
     delete(name: string): Promise<void>;
+    /**
+     * Poll for operation to become completed.
+     */
+    wait(op: OOBIOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedOOBIOperation>;
+    wait(op: QueryOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedQueryOperation>;
+    wait(op: EndRoleOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedEndRoleOperation>;
+    wait(op: WitnessOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedWitnessOperation>;
+    wait(op: DelegationOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDelegationOperation>;
+    wait(op: RegistryOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedRegistryOperation>;
+    wait(op: LocSchemeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedLocSchemeOperation>;
+    wait(op: ChallengeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedChallengeOperation>;
+    wait(op: ExchangeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedExchangeOperation>;
+    wait(op: SubmitOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedSubmitOperation>;
+    wait(op: DoneOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDoneOperation>;
+    wait(op: CredentialOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedCredentialOperation>;
+    wait(op: GroupOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedGroupOperation>;
+    wait(op: DelegatorOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDelegatorOperation>;
+    wait(op: Operation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedOperation>;
 }
 /**
  * KeyEvents
@@ -81,9 +180,9 @@ export declare class KeyEvents {
      * 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
      */
-    get(pre: string): Promise<any>;
+    get(pre: string): Promise<KeyEventRecord[]>;
 }
 /**
  * KeyStates
@@ -99,23 +198,33 @@ export declare class KeyStates {
      * 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
      */
-    get(pre: string): Promise<any>;
+    get(pre: string): Promise<KeyState[]>;
     /**
      * 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
      */
-    list(pres: string[]): Promise<any>;
+    list(pres: string[]): Promise<KeyState[]>;
     /**
      * 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
      */
-    query(pre: string, sn?: string, anchor?: any): Promise<any>;
+    query(pre: string, sn?: string, anchor?: any): Promise<QueryOperation>;
+}
+export declare class Config {
+    client: SignifyClient;
+    /**
+     * Config
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    get(): Promise<AgentConfig>;
 }
+export {};