signify-ts 0.1.0 → 0.2.0

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

@@ -1,151 +1,174 @@
-import { Encrypter } from "./encrypter";
-import { Decrypter } from "./decrypter";
-import { Salter, Tier } from "./salter";
-import { Signer } from "./signer";
-import { Verfer } from "./verfer";
-import { Diger } from "./diger";
-import { Cigar } from "./cigar";
-import { Siger } from "./siger";
-export declare enum Algos {
-    randy = "randy",
-    salty = "salty"
-}
-declare class PubLot {
-    pubs: Array<string>;
-    ridx: number;
-    kidx: number;
-    dt: string;
-}
-declare class PreSit {
-    old: PubLot;
-    new: PubLot;
-    nxt: PubLot;
-}
-declare class PrePrm {
-    pidx: number;
-    algo: Algos;
-    salt: string;
-    stem: string;
-    tier: string;
-}
-declare class PubSet {
-    pubs: Array<string>;
-}
-export interface Creator {
-    create(codes: Array<string> | undefined, count: number, code: string, transferable: boolean, pidx: number, ridx: number, kidx: number, temp: boolean): Array<Signer>;
-}
-export declare class RandyCreator implements Creator {
-    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean): Array<Signer>;
-    get salt(): string;
-    get stem(): string;
-    get tier(): Tier;
-}
-export declare class SaltyCreator implements Creator {
-    salter: Salter;
-    private readonly _stem;
-    constructor(salt?: string | undefined, tier?: Tier | undefined, stem?: string | undefined);
-    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>;
-}
-export declare class Creatory {
-    private _make;
-    constructor(algo?: Algos);
-    make(...args: any[]): any;
-    _makeRandy(): RandyCreator;
-    _makeSalty(...args: any[]): SaltyCreator;
-}
-export interface ManagerArgs {
-    ks?: KeyStore | undefined;
-    seed?: string | undefined;
-    aeid?: string | undefined;
-    pidx?: number | undefined;
-    algo?: string | undefined;
-    salt?: string | undefined;
-    tier?: string | undefined;
-}
-interface InceptArgs {
-    icodes?: any | undefined;
-    icount?: number;
-    icode?: string;
-    ncodes?: any | undefined;
-    ncount?: number;
-    ncode?: string;
-    dcode?: string;
-    algo?: Algos | undefined;
-    salt?: string | undefined;
-    stem?: string | undefined;
-    tier?: string | undefined;
-    rooted?: boolean;
-    transferable?: boolean;
-    temp?: boolean;
-}
-interface RotateArgs {
-    pre: string;
-    ncodes?: any | undefined;
-    ncount?: number;
-    ncode?: string;
-    dcode?: string;
-    transferable?: boolean;
-    temp?: boolean;
-    erase?: boolean;
-}
-interface SignArgs {
-    ser: Uint8Array;
-    pubs?: Array<string> | undefined;
-    verfers?: Array<Verfer> | undefined;
-    indexed?: boolean;
-    indices?: Array<number> | undefined;
-    ondices?: Array<number> | undefined;
-}
-export declare class Manager {
-    private _seed;
-    private _encrypter;
-    private _decrypter;
-    private _ks;
-    constructor({ ks, seed, aeid, pidx, algo, salt, tier }: ManagerArgs);
-    get ks(): KeyStore;
-    get encrypter(): Encrypter;
-    get decrypter(): Decrypter;
-    get seed(): string;
-    get aeid(): string | undefined;
-    get pidx(): number | undefined;
-    set pidx(pidx: number | undefined);
-    get salt(): string | undefined;
-    set salt(salt: string | undefined);
-    get tier(): string | undefined;
-    set tier(tier: string | undefined);
-    get algo(): Algos | undefined;
-    set algo(algo: string | 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[])[];
-    sign({ ser, pubs, verfers, indexed, indices, ondices }: SignArgs): Siger[] | Cigar[];
-}
-export declare function riKey(pre: string, ridx: number): string;
-export interface KeyStore {
-    getGbls(key: string): string | undefined;
-    pinGbls(key: string, val: string): void;
-    prmsElements(): Array<[string, PrePrm]>;
-    getPrms(keys: string): PrePrm | undefined;
-    pinPrms(keys: string, data: PrePrm): void;
-    putPrms(keys: string, data: PrePrm): boolean;
-    remPrms(keys: string): boolean;
-    prisElements(decrypter: Decrypter): Array<[string, Signer]>;
-    getPris(keys: string, decrypter: Decrypter): Signer | undefined;
-    pinPris(keys: string, data: Signer, encrypter: Encrypter): void;
-    putPris(pubKey: string, signer: Signer, encrypter: Encrypter): boolean;
-    getPres(pre: string): Uint8Array | undefined;
-    putPres(pre: string, val: Uint8Array): boolean;
-    pinPres(pre: string, val: Uint8Array): boolean;
-    getSits(keys: string): PreSit | undefined;
-    putSits(pre: string, val: PreSit): boolean;
-    pinSits(pre: string, val: PreSit): boolean;
-    remSits(keys: string): boolean;
-    getPubs(keys: string): PubSet | undefined;
-    putPubs(keys: string, data: PubSet): boolean;
-    remPubs(keys: string): boolean;
-}
-export {};
+import { Encrypter } from './encrypter';
+import { Decrypter } from './decrypter';
+import { Salter, Tier } from './salter';
+import { Signer } from './signer';
+import { Verfer } from './verfer';
+import { Diger } from './diger';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+export declare enum Algos {
+    randy = "randy",
+    salty = "salty",
+    group = "group",
+    extern = "extern"
+}
+declare class PubLot {
+    pubs: Array<string>;
+    ridx: number;
+    kidx: number;
+    dt: string;
+}
+declare class PreSit {
+    old: PubLot;
+    new: PubLot;
+    nxt: PubLot;
+}
+declare class PrePrm {
+    pidx: number;
+    algo: Algos;
+    salt: string;
+    stem: string;
+    tier: string;
+}
+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): Keys;
+    salt: string;
+    stem: string;
+    tier: Tier;
+}
+export declare class RandyCreator implements Creator {
+    create(codes?: Array<string> | undefined, count?: number, code?: string, transferable?: boolean): Keys;
+    get salt(): string;
+    get stem(): string;
+    get tier(): Tier;
+}
+export declare class SaltyCreator implements Creator {
+    salter: Salter;
+    private readonly _stem;
+    constructor(salt?: string | undefined, tier?: Tier | undefined, stem?: string | undefined);
+    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): Keys;
+}
+export declare class Creatory {
+    private readonly _make;
+    constructor(algo?: Algos);
+    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?: Algos | undefined;
+    salter?: Salter | undefined;
+    tier?: string | undefined;
+}
+export interface ManagerInceptArgs {
+    icodes?: any | undefined;
+    icount?: number;
+    icode?: string;
+    ncodes?: any | undefined;
+    ncount?: number;
+    ncode?: string;
+    dcode?: string;
+    algo?: Algos | undefined;
+    salt?: string | undefined;
+    stem?: string | undefined;
+    tier?: string | undefined;
+    rooted?: boolean;
+    transferable?: boolean;
+    temp?: boolean;
+}
+interface RotateArgs {
+    pre: string;
+    ncodes?: any | undefined;
+    ncount?: number;
+    ncode?: string;
+    dcode?: string;
+    transferable?: boolean;
+    temp?: boolean;
+    erase?: boolean;
+}
+interface SignArgs {
+    ser: Uint8Array;
+    pubs?: Array<string> | undefined;
+    verfers?: Array<Verfer> | undefined;
+    indexed?: boolean;
+    indices?: Array<number> | undefined;
+    ondices?: Array<number> | undefined;
+}
+export declare class Manager {
+    private _seed?;
+    private _salt?;
+    private _encrypter;
+    private _decrypter;
+    private readonly _ks;
+    constructor({ ks, seed, aeid, pidx, algo, salter, tier }: ManagerArgs);
+    get ks(): KeyStore;
+    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);
+    get salt(): string | undefined;
+    set salt(salt: string | undefined);
+    get tier(): string | undefined;
+    set tier(tier: string | undefined);
+    get algo(): Algos | undefined;
+    set algo(algo: Algos | undefined);
+    private updateAeid;
+    incept({ icodes, icount, icode, ncodes, ncount, ncode, dcode, algo, salt, stem, tier, rooted, transferable, temp, }: ManagerInceptArgs): [Array<Verfer>, Array<Diger>];
+    move(old: string, gnu: string): void;
+    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;
+export interface KeyStore {
+    getGbls(key: string): string | undefined;
+    pinGbls(key: string, val: string): void;
+    prmsElements(): Array<[string, PrePrm]>;
+    getPrms(keys: string): PrePrm | undefined;
+    pinPrms(keys: string, data: PrePrm): void;
+    putPrms(keys: string, data: PrePrm): boolean;
+    remPrms(keys: string): boolean;
+    prisElements(decrypter: Decrypter): Array<[string, Signer]>;
+    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;
+    getSits(keys: string): PreSit | undefined;
+    putSits(pre: string, val: PreSit): boolean;
+    pinSits(pre: string, val: PreSit): boolean;
+    remSits(keys: string): boolean;
+    getPubs(keys: string): PubSet | undefined;
+    putPubs(keys: string, data: PubSet): boolean;
+}
+export {};

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

@@ -1,47 +1,116 @@
-export declare class MatterCodex {
-    Ed25519_Seed: string;
-    Ed25519N: string;
-    X25519: string;
-    Ed25519: string;
-    Blake3_256: string;
-    X25519_Private: string;
-    X25519_Cipher_Seed: string;
-    X25519_Cipher_Salt: string;
-    Salt_128: string;
-    Ed25519_Sig: string;
-}
-export declare const MtrDex: MatterCodex;
-export declare class Sizage {
-    hs: number;
-    ss: number;
-    ls: number;
-    fs: number;
-    constructor(hs: number, ss: number, fs: number, ls: number);
-}
-export interface MatterArgs {
-    raw?: Uint8Array | undefined;
-    code?: string;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string;
-    qb2?: Uint8Array | undefined;
-}
-export declare class Matter {
-    static Sizes: Map<string, Sizage>;
-    static Hards: Map<string, number>;
-    private _code;
-    private _size;
-    private _raw;
-    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs);
-    get code(): string;
-    get size(): number;
-    get raw(): Uint8Array;
-    get qb64(): string;
-    get qb64b(): Uint8Array;
-    get transferable(): boolean;
-    static _rawSize(code: string): number;
-    static _leadSize(code: string): number;
-    get both(): string;
-    private _infil;
-    private _exfil;
-    private _bexfil;
-}
+export declare class Codex {
+    has(prop: string): boolean;
+}
+export declare class MatterCodex extends Codex {
+    Ed25519_Seed: string;
+    Ed25519N: string;
+    X25519: string;
+    Ed25519: string;
+    Blake3_256: string;
+    SHA3_256: string;
+    SHA2_256: string;
+    ECDSA_256k1_Seed: string;
+    X25519_Private: string;
+    X25519_Cipher_Seed: string;
+    ECDSA_256r1_Seed: string;
+    Salt_128: string;
+    Ed25519_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256r1_Sig: string;
+    StrB64_L0: string;
+    StrB64_L1: string;
+    StrB64_L2: string;
+    ECDSA_256k1N: string;
+    ECDSA_256k1: string;
+    X25519_Cipher_Salt: string;
+    ECDSA_256r1N: string;
+    ECDSA_256r1: string;
+    StrB64_Big_L0: string;
+    StrB64_Big_L1: string;
+    StrB64_Big_L2: string;
+}
+export declare const MtrDex: MatterCodex;
+export declare class NonTransCodex extends Codex {
+    Ed25519N: string;
+    ECDSA_256k1N: string;
+    Ed448N: string;
+    ECDSA_256r1N: 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 NumCodex extends Codex {
+    Short: string;
+    Long: string;
+    Big: string;
+    Huge: string;
+}
+export declare const NumDex: NumCodex;
+export declare class BexCodex extends Codex {
+    StrB64_L0: string;
+    StrB64_L1: string;
+    StrB64_L2: string;
+    StrB64_Big_L0: string;
+    StrB64_Big_L1: string;
+    StrB64_Big_L2: string;
+}
+export declare const BexDex: BexCodex;
+declare class SmallVarRawSizeCodex extends Codex {
+    Lead0: string;
+    Lead1: string;
+    Lead2: string;
+}
+export declare const SmallVrzDex: SmallVarRawSizeCodex;
+declare class LargeVarRawSizeCodex extends Codex {
+    Lead0_Big: string;
+    Lead1_Big: string;
+    Lead2_Big: string;
+}
+export declare const LargeVrzDex: LargeVarRawSizeCodex;
+export declare class Sizage {
+    hs: number;
+    ss: number;
+    ls?: number;
+    fs?: number;
+    constructor(hs: number, ss: number, fs?: number, ls?: number);
+}
+export interface MatterArgs {
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    rize?: number;
+}
+export declare class Matter {
+    static Sizes: Map<string, Sizage>;
+    static Hards: Map<string, number>;
+    private _code;
+    private _size;
+    private _raw;
+    constructor({ raw, code, qb64b, qb64, qb2, rize, }: MatterArgs);
+    get code(): string;
+    get size(): number;
+    get raw(): Uint8Array;
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+    get transferable(): boolean;
+    get digestive(): boolean;
+    static _rawSize(code: string): number;
+    static _leadSize(code: string): number | undefined;
+    get both(): string;
+    private _infil;
+    private _exfil;
+    private _bexfil;
+}
+export {};

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

@@ -0,0 +1,7 @@
+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

@@ -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 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

@@ -0,0 +1,31 @@
+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];