signify-ts 0.1.1 → 0.2.0

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

@@ -1,53 +1,59 @@
-export declare enum Serials {
-    JSON = "JSON"
-}
-export declare enum Ident {
-    KERI = "KERI"
-}
-export declare class Version {
-    major: number;
-    minor: number;
-    constructor(major?: number, minor?: number);
-}
-export declare const Versionage: Version;
-export declare const Ilks: {
-    icp: string;
-    rot: string;
-    ixn: string;
-    dip: string;
-    drt: string;
-    rct: string;
-    vrc: string;
-};
-export declare const IcpLabels: string[];
-export declare const DipLabels: string[];
-export declare const RotLabels: string[];
-export declare const DrtLabels: string[];
-export declare const IxnLabels: string[];
-export declare const KsnLabels: string[];
-export declare const RpyLabels: string[];
-export declare const VERFULLSIZE = 17;
-export declare const MINSNIFFSIZE: number;
-export declare const MINSIGSIZE = 4;
-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} 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): [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, 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;
+export declare enum Serials {
+    JSON = "JSON"
+}
+export declare enum Ident {
+    KERI = "KERI",
+    ACDC = "ACDC"
+}
+export declare class Version {
+    major: number;
+    minor: number;
+    constructor(major?: number, minor?: number);
+}
+export declare const Versionage: Version;
+export declare const Ilks: {
+    icp: string;
+    rot: string;
+    ixn: string;
+    dip: string;
+    drt: string;
+    rct: string;
+    vrc: string;
+    rpy: string;
+    exn: string;
+    vcp: string;
+    iss: string;
+    rev: string;
+};
+export declare const IcpLabels: string[];
+export declare const DipLabels: string[];
+export declare const RotLabels: string[];
+export declare const DrtLabels: string[];
+export declare const IxnLabels: string[];
+export declare const KsnLabels: string[];
+export declare const RpyLabels: string[];
+export declare const VERFULLSIZE = 17;
+export declare const MINSNIFFSIZE: number;
+export declare const MINSIGSIZE = 4;
+export declare const VEREX = "(KERI|ACDC)([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} versionString   version string
+ * @return {Object}  contaning prototol (KERI or ACDC), kind of serialization like cbor,json,mgpk
+ *                    version = version of object ,size = raw size integer
+ */
+export declare function deversify(versionString: string): [Ident, 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, 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

@@ -1,43 +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;
-}
+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/decrypter.d.ts

@@ -1,10 +1,10 @@
-import { Matter, MatterArgs } from './matter';
-import { Signer } from "./signer";
-import { Cipher } from "./cipher";
-import { Salter } from "./salter";
-export declare class Decrypter extends Matter {
-    private readonly _decrypt;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, seed?: Uint8Array | undefined);
-    decrypt(ser?: Uint8Array | null, cipher?: Cipher | null, transferable?: boolean): any;
-    _x25519(cipher: Cipher, prikey: Uint8Array, transferable?: boolean): Signer | Salter;
-}
+import { Matter, MatterArgs } from './matter';
+import { Signer } from './signer';
+import { Cipher } from './cipher';
+import { Salter } from './salter';
+export declare class Decrypter extends Matter {
+    private readonly _decrypt;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, seed?: Uint8Array | undefined);
+    decrypt(ser?: Uint8Array | null, cipher?: Cipher | null, transferable?: boolean): any;
+    _x25519(cipher: Cipher, prikey: Uint8Array, transferable?: boolean): Signer | Salter;
+}

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

@@ -1,21 +1,21 @@
-import { Matter, MatterArgs } from './matter';
-/**
- * @description : Diger is subset of Matter and is used to verify the digest of serialization
- * It uses  .raw : as digest
- * .code as digest algorithm
- *
- */
-export declare class Diger extends Matter {
-    private readonly _verify;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, ser?: Uint8Array | null);
-    /**
-     *
-     * @param {Uint8Array} ser  serialization bytes
-     * @description  This method will return true if digest of bytes serialization ser matches .raw
-     * using .raw as reference digest for ._verify digest algorithm determined
-     by .code
-     */
-    verify(ser: Uint8Array): boolean;
-    compare(ser: Uint8Array, dig?: any, diger?: Diger | null): boolean;
-    blake3_256(ser: Uint8Array, dig: any): boolean;
-}
+import { Matter, MatterArgs } from './matter';
+/**
+ * @description : Diger is subset of Matter and is used to verify the digest of serialization
+ * It uses  .raw : as digest
+ * .code as digest algorithm
+ *
+ */
+export declare class Diger extends Matter {
+    private readonly _verify;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, ser?: Uint8Array | null);
+    /**
+     *
+     * @param {Uint8Array} ser  serialization bytes
+     * @description  This method will return true if digest of bytes serialization ser matches .raw
+     * using .raw as reference digest for ._verify digest algorithm determined
+     by .code
+     */
+    verify(ser: Uint8Array): boolean;
+    compare(ser: Uint8Array, dig?: any, diger?: Diger | null): boolean;
+    blake3_256(ser: Uint8Array, dig: any): boolean;
+}

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

@@ -1,9 +1,9 @@
-import { Matter, MatterArgs } from './matter';
-import { Cipher } from "./cipher";
-export declare class Encrypter extends Matter {
-    private _encrypt;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verkey?: Uint8Array | null);
-    verifySeed(seed: Uint8Array): boolean;
-    encrypt(ser?: Uint8Array | null, matter?: Matter | null): any;
-    _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string): Cipher;
-}
+import { Matter, MatterArgs } from './matter';
+import { Cipher } from './cipher';
+export declare class Encrypter extends Matter {
+    private _encrypt;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verkey?: Uint8Array | null);
+    verifySeed(seed: Uint8Array): boolean;
+    encrypt(ser?: Uint8Array | null, matter?: Matter | null): any;
+    _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string): Cipher;
+}

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

@@ -1,21 +1,54 @@
-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;
+import { Serials, Version } from './core';
+import { Serder } from './serder';
+import { Siger } from './siger';
+import { Cigar } from './cigar';
+export interface RotateArgs {
+    pre?: string;
+    keys: Array<string>;
+    dig?: string;
+    ilk?: string;
+    sn?: number;
+    isith?: number | string | Array<string>;
+    ndigs?: Array<string>;
+    nsith?: number | string | Array<string>;
+    toad?: number;
+    wits?: Array<string>;
+    cuts?: Array<string>;
+    adds?: Array<string>;
+    cnfg?: Array<string>;
+    data?: Array<object>;
+    version?: Version;
+    kind?: Serials;
+    size?: number;
+    intive?: boolean;
+}
+export declare function rotate({ pre, keys, dig, ilk, sn, isith, ndigs, nsith, wits, cuts, adds, toad, data, version, kind, intive, }: RotateArgs): Serder;
+export declare function ample(n: number, f?: number, weak?: boolean): number;
+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;
+interface InteractArgs {
+    pre: string;
+    dig: string;
+    sn: number;
+    data: Array<any>;
+    version: Version | undefined;
+    kind: Serials | undefined;
+}
+export declare function interact(args: InteractArgs): Serder;
+export declare function reply(route: string | undefined, data: any | undefined, stamp: string | undefined, version: Version | undefined, kind?: Serials): Serder;
+export {};

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

@@ -1,34 +1,44 @@
-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>;
+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>;
+/** Parse start, end and total from HTTP Content-Range header value
+ * @param {string|null} header - HTTP Range header value
+ * @param {string} typ - type of range, e.g. "aids"
+ * @returns {start: number, end: number, total: number} - object with start, end and total properties
+ */
+export declare function parseRangeHeaders(header: string | null, typ: string): {
+    start: number;
+    end: number;
+    total: number;
+};

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

@@ -1,88 +1,98 @@
-export declare class IndexerCodex {
-    Ed25519_Sig: string;
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-}
-export declare const IdrDex: IndexerCodex;
-export declare class IndexedSigCodex {
-    Ed25519_Sig: string;
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxSigDex: IndexedSigCodex;
-export declare class IndexedCurrentSigCodex {
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxCrtSigDex: IndexedCurrentSigCodex;
-export declare class IndexedBothSigCodex {
-    Ed25519_Sig: string;
-    ECDSA_256k1_Sig: string;
-    Ed448_Sig: string;
-    Ed25519_Big_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    Ed448_Big_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxBthSigDex: IndexedBothSigCodex;
-export declare class Xizage {
-    hs: number;
-    ss: number;
-    os: number;
-    fs?: number;
-    ls: number;
-    constructor(hs: number, ss: number, os: number, fs?: number, ls?: number);
-}
-export interface IndexerArgs {
-    raw?: Uint8Array | undefined;
-    code?: string | undefined;
-    index?: number;
-    ondex?: number;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string | undefined;
-    qb2?: Uint8Array | undefined;
-}
-export declare class Indexer {
-    Codex: IndexerCodex;
-    static Hards: Map<string, number>;
-    static Sizes: Map<string, Xizage>;
-    private _code;
-    private _index;
-    private _ondex;
-    private _raw;
-    constructor({ raw, code, index, ondex, qb64b, qb64, qb2 }: IndexerArgs);
-    private _bexfil;
-    static _rawSize(code: string): number;
-    get code(): string;
-    get raw(): Uint8Array;
-    get index(): number;
-    get ondex(): number | undefined;
-    get qb64(): string;
-    get qb64b(): Uint8Array;
-    private _infil;
-    _exfil(qb64: string): void;
-}
+export declare class IndexerCodex {
+    Ed25519_Sig: string;
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+}
+export declare const IdrDex: IndexerCodex;
+export declare class IndexedSigCodex {
+    Ed25519_Sig: string;
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxSigDex: IndexedSigCodex;
+export declare class IndexedCurrentSigCodex {
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxCrtSigDex: IndexedCurrentSigCodex;
+export declare class IndexedBothSigCodex {
+    Ed25519_Sig: string;
+    ECDSA_256k1_Sig: string;
+    Ed448_Sig: string;
+    Ed25519_Big_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    Ed448_Big_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxBthSigDex: IndexedBothSigCodex;
+export declare class Xizage {
+    hs: number;
+    ss: number;
+    os: number;
+    fs?: number;
+    ls: number;
+    constructor(hs: number, ss: number, os: number, fs?: number, ls?: number);
+}
+export interface IndexerArgs {
+    raw?: Uint8Array | undefined;
+    code?: string | undefined;
+    index?: number;
+    ondex?: number;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string | undefined;
+    qb2?: Uint8Array | undefined;
+}
+export declare class Indexer {
+    Codex: IndexerCodex;
+    static Hards: Map<string, number>;
+    static Sizes: Map<string, Xizage>;
+    private _code;
+    private _index;
+    private _ondex;
+    private _raw;
+    constructor({ raw, code, index, ondex, qb64b, qb64, qb2, }: IndexerArgs);
+    private _bexfil;
+    static _rawSize(code: string): number;
+    get code(): string;
+    get raw(): Uint8Array;
+    get index(): number;
+    get ondex(): number | undefined;
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+    private _infil;
+    _exfil(qb64: string): void;
+}