signify-ts 0.1.0 → 0.1.1

package/README.md

@@ -16,10 +16,57 @@ Of the five functions in a KERI agent,
 
 Signify-TS splits off two, key generation and event signing into a TypeScript library to provide "signing at the edge".
 It accomplishes this by using libsodium to generate ed25510 key pairs for signing and x25519 key pairs for encrypting the
-private keys, next public keys any salts used to generate the private keys.  The encrypted private key and salts are then stored on a
+private keys, next public keys and salts used to generate the private keys.  The encrypted private key and salts are then stored on a
 remote cloud agent the never has access to the decryption keys.  New key pair sets (current and next) will be generated 
 for inception and rotation events with only the public keys and blake3 hash of next keys made available to the agent.
 
 The communication protocol between a Signify client and KERI agent will encode all cryptographic primitives as CESR base64
 encoded strings for the initial implementation.  Support for binary CESR can be added in the future.
 
+
+Account Creation Workflow
+
+
+sequenceDiagram
+    actor u as User
+    participant s as Signify
+    participant c as Cloud Agent
+    u ->> s: Create Account
+    s ->> s: Generate Pub/Pri Keys
+    s ->>+ c: Request ICP Event Creation with Keys
+    note over s,c: This call can not be secured
+    note right of c: Creates ICP Event
+    c ->>- s: Return ICP event
+    s ->>+ c: Create Account with Signed ICP Event
+    note over s,c: Call Signed by new Keys
+    note right of c: Parses and Saves ICP
+    note right of c: Create Account with new AID
+    c ->>- s: Return New Account KeyState
+    s ->>+ c: Save Key Information
+    c ->>- s: Key Information Saved
+    s ->> u: Return New Account Information
+
+
+sequenceDiagram
+    actor u as User
+    participant a as Web Page App
+    participant s as Signify
+    participant c as Cloud Agent
+    u ->> a: Create Account
+    a ->>+ s: Generate Pub/Pri Keys
+    s ->>- a: Return new Pub/Pri Keypair
+    a ->>+ c: Request ICP Event Creation with Keys
+    note over s,c: This call can not be secured
+    note right of c: Creates ICP Event
+    c ->>- a: Return ICP event
+    a ->>+ s: Sign ICP Event
+    s ->>- a: Return Signed Event
+    a ->>+ c: Create Account with Signed ICP Event
+    note over s,c: Call Signed by new Keys
+    note right of c: Parses and Saves ICP
+    note right of c: Create Account with new AID
+    c ->>- a: Return New Account KeyState
+    a ->>+ s: Save Key Information
+    s ->>+ c: Save Key Information
+    c ->>- s: Key Information Saved
+    a ->> u: Return New Account Information

package/dist/index.d.ts

@@ -1 +1,3 @@
-export declare const sum: (a: number, b: number) => number;
+export * from './keri/core/salter';
+export * from './keri/core/matter';
+export * from './keri/app/habery';

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

@@ -0,0 +1,10 @@
+import { Manager } from "../core/manager";
+export declare class Accountant {
+    private readonly _agentKey;
+    private readonly _mgr;
+    private readonly _ready;
+    constructor(mgr: Manager, agentKey: string);
+    get ready(): Promise<void>;
+    sign(): Manager;
+    verify(): string;
+}

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

@@ -0,0 +1 @@
+export declare function randomPasscode(): string;

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

@@ -0,0 +1,7 @@
+export declare class Client {
+    private readonly _url;
+    constructor(url: string);
+    url(path: string): string;
+    getAccount(name: string): Promise<Response>;
+    createAccount(name: string, key: string, ndig: string): Promise<Response>;
+}

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

@@ -0,0 +1,47 @@
+import { Manager } from "../core/manager";
+import { Serder } from "../core/serder";
+export declare class TraitCodex {
+    EstOnly: string;
+    DoNotDelegate: string;
+}
+export declare const TraitDex: TraitCodex;
+export interface HaberyArgs {
+    name: string;
+    passcode?: string;
+    seed?: string | undefined;
+    aeid?: string | undefined;
+    pidx?: number | undefined;
+    salt?: string | undefined;
+    tier?: string | undefined;
+}
+export interface MakeHabArgs {
+    code?: string;
+    transferable?: boolean;
+    isith?: string;
+    icount?: number;
+    nsith?: string;
+    ncount?: number;
+    toad?: string | number;
+    wits?: Array<string>;
+    delpre?: string;
+    estOnly?: boolean;
+    DnD?: boolean;
+    data?: any;
+}
+export declare class Hab {
+    name: string;
+    serder: Serder;
+    constructor(name: string, icp: Serder);
+    get pre(): string;
+}
+export declare class Habery {
+    private readonly _name;
+    private readonly _mgr;
+    private readonly _habs;
+    constructor({ name, passcode, seed, aeid, pidx, salt }: HaberyArgs);
+    get mgr(): Manager;
+    get habs(): Array<Hab>;
+    habByName(name: string): Hab | undefined;
+    makeHab(name: string, { code, transferable, isith, icount, nsith, ncount, toad, wits, delpre, estOnly, DnD, data }: MakeHabArgs): Hab;
+    get name(): string;
+}

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

@@ -0,0 +1,6 @@
+export declare class Signify {
+    private readonly _hby?;
+    private readonly _act?;
+    private readonly _client?;
+    constructor(url: string, name: string, passcode: string);
+}

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

@@ -0,0 +1,9 @@
+import { Signer } from "./signer";
+export declare class Authenticater {
+    static DefaultFields: string[];
+    private _verfer;
+    private readonly _csig;
+    constructor(csig: Signer, aaid: string);
+    verify(headers: Headers, method: string, path: string): boolean;
+    sign(headers: Headers, method: string, path: string, fields?: Array<string>): Headers;
+}

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

@@ -2,7 +2,7 @@ import { Verfer } from "./verfer";
 import { Matter, MatterArgs } from "./matter";
 export declare class Cigar extends Matter {
     private _verfer;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer: Verfer);
-    get verfer(): Verfer;
-    set verfer(verfer: Verfer);
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer);
+    get verfer(): Verfer | undefined;
+    set verfer(verfer: Verfer | undefined);
 }

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

@@ -1,25 +1,15 @@
-export declare const VERRAWSIZE = 6;
-export declare const Versionage: {
+export declare enum Serials {
+    JSON = "JSON"
+}
+export declare enum Ident {
+    KERI = "KERI"
+}
+export declare class Version {
     major: number;
     minor: number;
-};
-export declare const Serialage: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const Vstrings: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const Serials: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const IcpExcludes: string[];
-export declare const DipExcludes: string[];
+    constructor(major?: number, minor?: number);
+}
+export declare const Versionage: Version;
 export declare const Ilks: {
     icp: string;
     rot: string;
@@ -39,30 +29,25 @@ export declare const RpyLabels: string[];
 export declare const VERFULLSIZE = 17;
 export declare const MINSNIFFSIZE: number;
 export declare const MINSIGSIZE = 4;
-/**
- * @description  It will return version string
- */
-export declare function versify(version: {
-    major: number;
-    minor: number;
-}, kind: string | undefined, size: number): string;
-export declare const VEREX = "KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})";
+export declare const VEREX = "KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_";
+export interface Dict<TValue> {
+    [id: string]: TValue;
+}
 /**
  * @description This function is use to deversify the version
  * Here we will use regex to  to validate and extract serialization kind,size and version
- * @param {string} vs   version string
+ * @param {string} versionString   version string
  * @return {Object}  contaning kind of serialization like cbor,json,mgpk
  *                    version = version of object ,size = raw size integer
  */
-export declare function deversify(versionString: string): (string | {
-    major: number;
-    minor: number;
-})[];
+export declare function deversify(versionString: string): [Serials, Version, string];
+export declare function versify(ident?: Ident, version?: Version, kind?: Serials, size?: number): string;
 export declare const B64ChrByIdx: Map<number, string>;
 export declare const B64IdxByChr: Map<string, number>;
-export declare function intToB64(i: number | undefined, l?: number): string;
+export declare function intToB64(i: number, l?: number): string;
 export declare function intToB64b(n: number, l?: number): Uint8Array;
 export declare function b64ToInt(s: string): number;
 export declare function b(s?: string): Uint8Array;
 export declare function d(u?: Uint8Array): string;
+export declare function concat(one: Uint8Array, two: Uint8Array): Uint8Array;
 export declare function readInt(array: Uint8Array): number;

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

@@ -0,0 +1,43 @@
+import { Codex, Sizage } from "./matter";
+export interface CounterArgs {
+    code?: string;
+    count?: number;
+    countB64?: string;
+    qb64b?: Uint8Array;
+    qb64?: string;
+    qb2?: Uint8Array;
+    strip?: boolean;
+}
+export declare class CounterCodex extends Codex {
+    ControllerIdxSigs: string;
+    WitnessIdxSigs: string;
+    NonTransReceiptCouples: string;
+    TransReceiptQuadruples: string;
+    FirstSeenReplayCouples: string;
+    TransIdxSigGroups: string;
+    SealSourceCouples: string;
+    TransLastIdxSigGroups: string;
+    SealSourceTriples: string;
+    SadPathSig: string;
+    SadPathSigGroup: string;
+    PathedMaterialQuadlets: string;
+    AttachedMaterialQuadlets: string;
+    BigAttachedMaterialQuadlets: string;
+    KERIProtocolStack: string;
+}
+export declare const CtrDex: CounterCodex;
+export declare class Counter {
+    static Sizes: Map<string, Sizage>;
+    static Hards: Map<string, number>;
+    private _code;
+    private _count;
+    constructor({ code, count, countB64, qb64b, qb64, qb2 }: CounterArgs);
+    get code(): string;
+    get count(): number;
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+    countToB64(l?: number): string;
+    static semVerToB64(version?: string, major?: number, minor?: number, patch?: number): string;
+    private _infil;
+    private _exfil;
+}

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

@@ -0,0 +1,21 @@
+import { Serials, Version } from "./core";
+import { Serder } from "./serder";
+import { Siger } from "./siger";
+import { Cigar } from "./cigar";
+export interface InceptArgs {
+    keys: Array<string>;
+    isith?: number | string | Array<string>;
+    ndigs?: Array<string>;
+    nsith?: number | string | Array<string>;
+    toad?: number | string;
+    wits?: Array<string>;
+    cnfg?: Array<string>;
+    data?: Array<object>;
+    version?: Version;
+    kind?: Serials;
+    code?: string;
+    intive?: boolean;
+    delpre?: string;
+}
+export declare function incept({ keys, isith, ndigs, nsith, toad, wits, cnfg, data, version, kind, code, intive, delpre }: InceptArgs): Serder;
+export declare function messagize(serder: Serder, sigers?: Array<Siger>, seal?: any, wigers?: Array<Cigar>, cigars?: Array<Cigar>, pipelined?: boolean): Uint8Array;

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

@@ -0,0 +1,34 @@
+import { Signer } from "./signer";
+import { Cigar } from "./cigar";
+import { Siger } from "./siger";
+export declare function normalize(header: string): string;
+export interface SiginputArgs {
+    name: string;
+    method: string;
+    path: string;
+    headers: Headers;
+    fields: Array<string>;
+    expires?: number;
+    nonce?: string;
+    alg?: string;
+    keyid?: string;
+    context?: string;
+}
+export declare function siginput(signer: Signer, { name, method, path, headers, fields, expires, nonce, alg, keyid, context }: SiginputArgs): [Map<string, string>, Siger | Cigar];
+export declare class Unqualified {
+    private readonly _raw;
+    constructor(raw: Uint8Array);
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+}
+export declare class Inputage {
+    name: any;
+    fields: any;
+    created: any;
+    expires: any;
+    nonce: any;
+    alg: any;
+    keyid: any;
+    context: any;
+}
+export declare function desiginput(value: string): Array<Inputage>;

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

@@ -31,11 +31,27 @@ declare class PrePrm {
 declare class PubSet {
     pubs: Array<string>;
 }
+declare class PubPath {
+    path: string;
+    code: string;
+    tier: string;
+    temp: boolean;
+}
+declare class Keys {
+    private readonly _signers;
+    private readonly _paths?;
+    constructor(signers: Array<Signer>, paths?: Array<string>);
+    get paths(): Array<string> | undefined;
+    get signers(): Array<Signer>;
+}
 export interface Creator {
-    create(codes: Array<string> | undefined, count: number, code: string, transferable: boolean, pidx: number, ridx: number, kidx: number, temp: boolean): Array<Signer>;
+    create(codes: Array<string> | undefined, count: number, code: string, transferable: boolean, pidx: number, ridx: number, kidx: number, temp: boolean): Keys;
+    salt: string;
+    stem: string;
+    tier: Tier;
 }
 export declare class RandyCreator implements Creator {
-    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean): Array<Signer>;
+    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean): Keys;
     get salt(): string;
     get stem(): string;
     get tier(): Tier;
@@ -47,25 +63,26 @@ export declare class SaltyCreator implements Creator {
     get salt(): string;
     get stem(): string;
     get tier(): Tier;
-    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean, pidx?: number, ridx?: number, kidx?: number, temp?: boolean): Array<Signer>;
+    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean, pidx?: number, ridx?: number, kidx?: number, temp?: boolean): Keys;
 }
 export declare class Creatory {
-    private _make;
+    private readonly _make;
     constructor(algo?: Algos);
-    make(...args: any[]): any;
-    _makeRandy(): RandyCreator;
-    _makeSalty(...args: any[]): SaltyCreator;
+    make(...args: any[]): Creator;
+    _makeRandy(): Creator;
+    _makeSalty(...args: any[]): Creator;
 }
+export declare function openManager(passcode: string, salt?: string): Manager;
 export interface ManagerArgs {
     ks?: KeyStore | undefined;
     seed?: string | undefined;
     aeid?: string | undefined;
     pidx?: number | undefined;
-    algo?: string | undefined;
+    algo?: Algos | undefined;
     salt?: string | undefined;
     tier?: string | undefined;
 }
-interface InceptArgs {
+export interface InceptArgs {
     icodes?: any | undefined;
     icount?: number;
     icode?: string;
@@ -100,15 +117,16 @@ interface SignArgs {
     ondices?: Array<number> | undefined;
 }
 export declare class Manager {
-    private _seed;
+    private _seed?;
+    private _salt?;
     private _encrypter;
     private _decrypter;
-    private _ks;
+    private readonly _ks;
     constructor({ ks, seed, aeid, pidx, algo, salt, tier }: ManagerArgs);
     get ks(): KeyStore;
-    get encrypter(): Encrypter;
-    get decrypter(): Decrypter;
-    get seed(): string;
+    get encrypter(): Encrypter | undefined;
+    get decrypter(): Decrypter | undefined;
+    get seed(): string | undefined;
     get aeid(): string | undefined;
     get pidx(): number | undefined;
     set pidx(pidx: number | undefined);
@@ -117,11 +135,11 @@ export declare class Manager {
     get tier(): string | undefined;
     set tier(tier: string | undefined);
     get algo(): Algos | undefined;
-    set algo(algo: string | undefined);
+    set algo(algo: Algos | undefined);
     private updateAeid;
     incept({ icodes, icount, icode, ncodes, ncount, ncode, dcode, algo, salt, stem, tier, rooted, transferable, temp }: InceptArgs): [Array<Verfer>, Array<Diger>];
     move(old: string, gnu: string): void;
-    rotate({ pre, ncodes, ncount, ncode, dcode, transferable, temp, erase }: RotateArgs): (Verfer[] | Diger[])[];
+    rotate({ pre, ncodes, ncount, ncode, dcode, transferable, temp, erase }: RotateArgs): [Array<Verfer>, Array<Diger>];
     sign({ ser, pubs, verfers, indexed, indices, ondices }: SignArgs): Siger[] | Cigar[];
 }
 export declare function riKey(pre: string, ridx: number): string;
@@ -137,6 +155,10 @@ export interface KeyStore {
     getPris(keys: string, decrypter: Decrypter): Signer | undefined;
     pinPris(keys: string, data: Signer, encrypter: Encrypter): void;
     putPris(pubKey: string, signer: Signer, encrypter: Encrypter): boolean;
+    remPris(pubKey: string): void;
+    getPths(pubKey: string): PubPath | undefined;
+    putPths(pubKey: string, val: PubPath): boolean;
+    pinPths(pubKey: string, val: PubPath): boolean;
     getPres(pre: string): Uint8Array | undefined;
     putPres(pre: string, val: Uint8Array): boolean;
     pinPres(pre: string, val: Uint8Array): boolean;
@@ -146,6 +168,5 @@ export interface KeyStore {
     remSits(keys: string): boolean;
     getPubs(keys: string): PubSet | undefined;
     putPubs(keys: string, data: PubSet): boolean;
-    remPubs(keys: string): boolean;
 }
 export {};

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

@@ -1,4 +1,7 @@
-export declare class MatterCodex {
+export declare class Codex {
+    has(prop: string): boolean;
+}
+export declare class MatterCodex extends Codex {
     Ed25519_Seed: string;
     Ed25519N: string;
     X25519: string;
@@ -11,6 +14,24 @@ export declare class MatterCodex {
     Ed25519_Sig: string;
 }
 export declare const MtrDex: MatterCodex;
+export declare class NonTransCodex extends Codex {
+    Ed25519N: string;
+    ECDSA_256k1N: string;
+    Ed448N: string;
+}
+export declare const NonTransDex: NonTransCodex;
+export declare class DigiCodex extends Codex {
+    Blake3_256: string;
+    Blake2b_256: string;
+    Blake2s_256: string;
+    SHA3_256: string;
+    SHA2_256: string;
+    Blake3_512: string;
+    Blake2b_512: string;
+    SHA3_512: string;
+    SHA2_512: string;
+}
+export declare const DigiDex: DigiCodex;
 export declare class Sizage {
     hs: number;
     ss: number;
@@ -38,6 +59,7 @@ export declare class Matter {
     get qb64(): string;
     get qb64b(): Uint8Array;
     get transferable(): boolean;
+    get digestive(): boolean;
     static _rawSize(code: string): number;
     static _leadSize(code: string): number;
     get both(): string;

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

@@ -0,0 +1,6 @@
+export declare class PNumber {
+    private readonly _num;
+    constructor(num?: number | string, numh?: string);
+    get num(): number;
+    get numh(): string;
+}

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

@@ -0,0 +1,15 @@
+import { Matter, MatterArgs } from "./matter";
+import { Dict } from "./core";
+export declare class Prefixer extends Matter {
+    private readonly _derive;
+    private readonly _verify;
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, ked?: Dict<any>);
+    derive(ked: Dict<any>): [Uint8Array, string];
+    verify(ked: Dict<any>, prefixed?: boolean): boolean;
+    static _derive_ed25519N(ked: Dict<any>): [Uint8Array, string];
+    static _derive_ed25519(ked: Dict<any>): [Uint8Array, string];
+    static _derive_blake3_256(ked: Dict<any>): [Uint8Array, string];
+    _verify_ed25519N(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
+    _verify_ed25519(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
+    _verify_blake3_256(ked: Dict<any>, pre: string, prefixed?: boolean): boolean;
+}

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

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { Matter, MatterArgs } from "./matter";
+import { Dict, Serials } from "./core";
+export declare enum Ids {
+    d = "d"
+}
+declare class Digestage {
+    klas: any;
+    size: number | undefined;
+    length: number | undefined;
+    constructor(klas: any, size?: number, length?: number);
+}
+export declare class Saider extends Matter {
+    static Digests: Map<string, Digestage>;
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, sad?: Dict<any>, kind?: Serials, label?: string);
+    static _derive_blake3_256(ser: Uint8Array, _digest_size: number, _length: number): Buffer;
+    private static _derive;
+    derive(sad: Dict<any>, code: string, kind: Serials | undefined, label: string): [Uint8Array, Dict<any>];
+    verify(sad: Dict<any>, prefixed?: boolean, versioned?: boolean, kind?: Serials, label?: string): boolean;
+    private static _serialze;
+    static saidify(sad: Dict<any>, code?: string, kind?: Serials, label?: string): [Saider, Dict<any>];
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { Signer } from "./signer";
+import { Matter } from './matter';
+export declare const enum Tier {
+    low = "low",
+    med = "med",
+    high = "high"
+}
+interface SalterArgs {
+    raw?: Uint8Array | undefined;
+    code?: string;
+    tier?: Tier;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+}
+export declare class Salter extends Matter {
+    private readonly _tier;
+    constructor({ raw, code, tier, qb64, qb64b, qb2 }: SalterArgs);
+    private stretch;
+    signer(code?: string, transferable?: boolean, path?: string, tier?: Tier | null, temp?: boolean): Signer;
+    get tier(): Tier | null;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { Dict, Ident, Serials, Version } from "./core";
+export declare class Serder {
+    private _kind;
+    private _raw;
+    private _ked;
+    private _ident;
+    private _size;
+    private _version;
+    private readonly _code;
+    constructor(ked: Dict<any>, kind?: Serials, code?: string);
+    set ked(ked: Dict<any>);
+    get ked(): Dict<any>;
+    get code(): string;
+    get raw(): string;
+    get kind(): Serials;
+    private _exhale;
+    get ident(): Ident;
+    get size(): number;
+    get version(): Version;
+    pretty(): string;
+}
+export declare function dumps(ked: Object, kind: Serials.JSON): string;
+export declare function sizeify(ked: Dict<any>, kind?: Serials): [string, Ident, Serials, Dict<any>, Version];

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

@@ -16,7 +16,7 @@ import { Verfer } from "./verfer";
  **/
 export declare class Siger extends Indexer {
     private _verfer?;
-    constructor({ raw, code, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
+    constructor({ raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
     get verfer(): Verfer | undefined;
     set verfer(verfer: Verfer | undefined);
 }

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

@@ -29,6 +29,6 @@ export declare class Signer extends Matter {
      Assumes ._verfer is correctly assigned
      */
     get verfer(): Verfer;
-    sign(ser: Uint8Array, index?: number | null, only?: boolean, ondex?: number | undefined): any;
-    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null, only: boolean | undefined, ondex: number | undefined): Cigar | Siger;
+    sign(ser: Uint8Array, index?: number | null, only?: boolean, ondex?: number | undefined): Siger | Cigar;
+    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null, only: boolean | undefined, ondex: number | undefined): Siger | Cigar;
 }

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

@@ -0,0 +1,14 @@
+export declare class Tholder {
+    private _weighted;
+    private _thold;
+    private _size;
+    private _sith;
+    private _limen;
+    constructor(sith: string | number | Array<string>);
+    get num(): number | undefined;
+    get size(): number;
+    get thold(): number;
+    get weighted(): boolean;
+    get sith(): string;
+    private processSith;
+}

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

@@ -13,4 +13,5 @@ export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
 
  * @param {*} obj
  */
-export declare function range(start: any, stop: any, step: any): any[];
+export declare function nowUTC(): Date;
+export declare function range(start: number, stop: number, step: number): number[];

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

@@ -0,0 +1,12 @@
+export {};
+import { Matter, MatterArgs } from './matter';
+/**
+ * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
+ *  using .raw as verifier key and .code as signature cypher suite
+ */
+export declare class Verfer extends Matter {
+    private readonly _verify;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
+    verify(sig: any, ser: any): boolean;
+    _ed25519(sig: any, ser: any, key: any): boolean;
+}