signify-ts 0.1.1 → 0.2.0

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

@@ -1,6 +1,7 @@
-export declare class PNumber {
-    private readonly _num;
-    constructor(num?: number | string, numh?: string);
-    get num(): number;
-    get numh(): string;
-}
+import { Matter, MatterArgs } from './matter';
+export declare class CesrNumber extends Matter {
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, num?: number | string, numh?: string);
+    get num(): number;
+    get numh(): string;
+    get positive(): boolean;
+}

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

@@ -0,0 +1,7 @@
+import { Bexter } from './bexter';
+import { MatterArgs } from './matter';
+export declare class Pather extends Bexter {
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, bext?: string, path?: string[]);
+    get path(): string[];
+    static _bextify(path: any[]): string;
+}

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

@@ -1,15 +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;
-}
+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

@@ -1,23 +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 {};
+/// <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

@@ -1,23 +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 {};
+import { Signer } from './signer';
+import { Matter } from './matter';
+export declare 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/seqner.d.ts

@@ -0,0 +1,15 @@
+import { Matter, MatterArgs } from './matter';
+/**
+ * @description  Seqner: subclass of Matter, cryptographic material, for ordinal numbers
+ * such as sequence numbers or first seen ordering numbers.
+ * Seqner provides fully qualified format for ordinals (sequence numbers etc)
+ * when provided as attached cryptographic material elements.
+ */
+export declare class Seqner extends Matter {
+    constructor({ raw, code, qb64, qb64b, qb2, sn, snh, ...kwa }: MatterArgs & {
+        sn?: number;
+        snh?: string;
+    });
+    get sn(): number;
+    get snh(): string;
+}

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

@@ -1,23 +1,31 @@
-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];
+import { Dict, Ident, Serials, Version } from './core';
+import { Verfer } from './verfer';
+import { Diger } from './diger';
+import { CesrNumber } from './number';
+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 pre(): string;
+    get ked(): Dict<any>;
+    get code(): string;
+    get raw(): string;
+    get sner(): CesrNumber;
+    get sn(): number;
+    get kind(): Serials;
+    private _exhale;
+    get ident(): Ident;
+    get size(): number;
+    get version(): Version;
+    get verfers(): Verfer[];
+    get digers(): Diger[];
+    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

@@ -1,22 +1,22 @@
-import { Indexer, IndexerArgs } from "./indexer";
-import { Verfer } from "./verfer";
-/**
-   Siger is subclass of Indexer, indexed signature material,
-    Adds .verfer property which is instance of Verfer that provides
-          associated signature verifier.
+import { Indexer, IndexerArgs } from './indexer';
+import { Verfer } from './verfer';
+/**
+   Siger is subclass of Indexer, indexed signature material,
+    Adds .verfer property which is instance of Verfer that provides
+          associated signature verifier.
 
-    See Indexer for inherited attributes and properties:
+    See Indexer for inherited attributes and properties:
 
-    Attributes:
+    Attributes:
 
-    Properties:
-        .verfer is Verfer object instance
+    Properties:
+        .verfer is Verfer object instance
 
-    Methods:
- **/
-export declare class Siger extends Indexer {
-    private _verfer?;
-    constructor({ raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
-    get verfer(): Verfer | undefined;
-    set verfer(verfer: Verfer | undefined);
-}
+    Methods:
+ **/
+export declare class Siger extends Indexer {
+    private _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

@@ -1,34 +1,34 @@
-export {};
-import { Matter } from './matter';
-import { Verfer } from "./verfer";
-import { Cigar } from "./cigar";
-import { Siger } from "./siger";
-/**
- * @description Signer is Matter subclass with method to create signature of serialization
- * It will use .raw as signing (private) key seed
- * .code as cipher suite for signing and new property .verfer whose property
- *  .raw is public key for signing.
- *  If not provided .verfer is generated from private key seed using .code
- as cipher suite for creating key-pair.
- */
-interface SignerArgs {
-    raw?: Uint8Array | undefined;
-    code?: string;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string;
-    qb2?: Uint8Array | undefined;
-    transferable?: boolean;
-}
-export declare class Signer extends Matter {
-    private readonly _sign;
-    private readonly _verfer;
-    constructor({ raw, code, qb64, qb64b, qb2, transferable }: SignerArgs);
-    /**
-     * @description Property verfer:
-     Returns Verfer instance
-     Assumes ._verfer is correctly assigned
-     */
-    get verfer(): Verfer;
-    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;
-}
+export {};
+import { Matter } from './matter';
+import { Verfer } from './verfer';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+/**
+ * @description Signer is Matter subclass with method to create signature of serialization
+ * It will use .raw as signing (private) key seed
+ * .code as cipher suite for signing and new property .verfer whose property
+ *  .raw is public key for signing.
+ *  If not provided .verfer is generated from private key seed using .code
+ as cipher suite for creating key-pair.
+ */
+interface SignerArgs {
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    transferable?: boolean;
+}
+export declare class Signer extends Matter {
+    private readonly _sign;
+    private readonly _verfer;
+    constructor({ raw, code, qb64, qb64b, qb2, transferable, }: SignerArgs);
+    /**
+     * @description Property verfer:
+     Returns Verfer instance
+     Assumes ._verfer is correctly assigned
+     */
+    get verfer(): Verfer;
+    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): Cigar | Siger;
+}

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

@@ -1,14 +1,29 @@
-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;
-}
+export declare class Tholder {
+    private _weighted;
+    private _thold;
+    private _size;
+    private _number;
+    private _satisfy;
+    constructor(kargs: {
+        thold?: any;
+        limen?: any;
+        sith?: any;
+    });
+    get weighted(): boolean;
+    get thold(): any;
+    get size(): number;
+    get limen(): any;
+    get sith(): string;
+    get json(): string;
+    get num(): number | undefined;
+    private _processThold;
+    private _processLimen;
+    private _processSith;
+    private _processClauses;
+    private _processUnweighted;
+    private _processWeighted;
+    private weight;
+    private _satisfy_numeric;
+    private _satisfy_weighted;
+    satisfy(indices: any): boolean;
+}

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

@@ -1,17 +1,22 @@
-export declare function pad(n: any, width?: number, z?: number): string;
-/**
- * @description  Returns list of depth first recursively extracted values from elements of
-    key event dict ked whose flabels are in lables list
+import { Serder } from './serder';
+export declare function pad(n: any, width?: number, z?: number): string;
+/**
+ * @description  Returns list of depth first recursively extracted values from elements of
+    key event dict ked whose flabels are in lables list
 
- * @param {*} ked  ked is key event dict
- * @param {*} labels    labels is list of element labels in ked from which to extract values
- */
-export declare function extractValues(ked: any, labels: any): any;
-export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
-/**
- * @description Returns True if obj is non-string iterable, False otherwise
+ * @param {*} ked  ked is key event dict
+ * @param {*} labels    labels is list of element labels in ked from which to extract values
+ */
+export declare function extractValues(ked: any, labels: any): any;
+export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
+/**
+ * @description Returns True if obj is non-string iterable, False otherwise
 
- * @param {*} obj
- */
-export declare function nowUTC(): Date;
-export declare function range(start: number, stop: number, step: number): number[];
+ * @param {*} obj
+ */
+export declare function nowUTC(): Date;
+export declare function range(start: number, stop: number, step: number): number[];
+export declare function intToBytes(value: number, length: number): Uint8Array;
+export declare function bytesToInt(ar: Uint8Array): number;
+export declare function serializeACDCAttachment(anc: Serder): Uint8Array;
+export declare function serializeIssExnAttachment(anc: Serder): Uint8Array;

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

@@ -0,0 +1,16 @@
+import { Serials, Version } from '../core/core';
+import { Serder } from './serder';
+declare namespace vdr {
+    interface VDRInceptArgs {
+        pre: string;
+        toad?: number | string;
+        nonce?: string;
+        baks?: string[];
+        cnfg?: string[];
+        version?: Version;
+        kind?: Serials;
+        code?: string;
+    }
+    function incept({ pre, toad, nonce, baks, cnfg, version, kind, code, }: VDRInceptArgs): Serder;
+}
+export { vdr };

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

@@ -1,12 +1,13 @@
-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;
-}
+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;
+    _secp256r1(sig: any, ser: any, key: any): any;
+}

package/dist/keri/end/ending.d.ts

@@ -1,13 +1,13 @@
-export declare const FALSY: (string | number | boolean)[];
-export declare const TRUTHY: (string | number | boolean)[];
-export declare class Signage {
-    constructor(markers: any, indexed?: boolean, signer?: string, ordinal?: string, digest?: string, kind?: string);
-    markers: any;
-    indexed: boolean | undefined;
-    signer: string | undefined;
-    ordinal: string | undefined;
-    digest: string | undefined;
-    kind: string | undefined;
-}
-export declare function signature(signages: Array<Signage>): Headers;
-export declare function designature(value: string): Signage[];
+export declare const FALSY: (string | number | boolean)[];
+export declare const TRUTHY: (string | number | boolean)[];
+export declare class Signage {
+    constructor(markers: any, indexed?: boolean, signer?: string, ordinal?: string, digest?: string, kind?: string);
+    markers: any;
+    indexed: boolean | undefined;
+    signer: string | undefined;
+    ordinal: string | undefined;
+    digest: string | undefined;
+    kind: string | undefined;
+}
+export declare function signature(signages: Array<Signage>): Headers;
+export declare function designature(value: string): Signage[];

package/dist/math.d.ts

@@ -0,0 +1 @@
+export declare const math: import("mathjs").MathJsStatic;

package/dist/ready.d.ts

@@ -0,0 +1 @@
+export declare const ready: () => Promise<void>;