signify-ts 0.2.1 → 0.3.0-rc2

package/dist/keri/core/base64.js

@@ -0,0 +1,16 @@
+import { fromByteArray, toByteArray } from 'base64-js';
+export function encodeBase64Url(input) {
+    return fromByteArray(input)
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+/, '');
+}
+export function decodeBase64Url(input) {
+    if (!(typeof input === 'string')) {
+        throw new TypeError('`input` must be a string.');
+    }
+    const n = input.length % 4;
+    const padded = input + '='.repeat(n > 0 ? 4 - n : n);
+    const base64String = padded.replace(/-/g, '+').replace(/_/g, '/');
+    return toByteArray(base64String);
+}

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

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 export declare const Reb64: RegExp;
 export declare class Bexter extends Matter {
     constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, bext?: string);

package/{src/keri/core/bexter.ts → dist/keri/core/bexter.js}

@@ -1,10 +1,9 @@
-import { BexDex, Matter, MatterArgs, MtrDex } from './matter';
-import { EmptyMaterialError } from './kering';
-import Base64 from 'urlsafe-base64';
-
+import { BexDex, Matter, MtrDex } from "./matter.js";
+import { EmptyMaterialError } from "./kering.js";
+import { decodeBase64Url, encodeBase64Url } from "./base64.js";
+import { concat } from "./core.js";
 const B64REX = '^[A-Za-z0-9\\-_]*$';
 export const Reb64 = new RegExp(B64REX);
-
 /*
 
     Bexter is subclass of Matter, cryptographic material, for variable length
@@ -80,59 +79,46 @@ export const Reb64 = new RegExp(B64REX);
 
 
  */
-
 export class Bexter extends Matter {
-    constructor(
-        { raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }: MatterArgs,
-        bext?: string
-    ) {
-        if (
-            raw === undefined &&
+    constructor({ raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }, bext) {
+        if (raw === undefined &&
             qb64b === undefined &&
             qb64 === undefined &&
-            qb2 === undefined
-        ) {
+            qb2 === undefined) {
             if (bext === undefined)
                 throw new EmptyMaterialError('Missing bext string.');
-
             const match = Reb64.exec(bext);
-            if (!match) throw new Error('Invalid Base64.');
-
+            if (!match)
+                throw new Error('Invalid Base64.');
             raw = Bexter._rawify(bext);
         }
-
         super({ raw, code, qb64b, qb64, qb2 });
-
         if (!BexDex.has(this.code))
             throw new Error(`Invalid code = ${this.code} for Bexter.`);
     }
-
-    static _rawify(bext: string): Uint8Array {
+    static _rawify(bext) {
         const ts = bext.length % 4; // bext size mod 4
         const ws = (4 - ts) % 4; // pre conv wad size in chars
         const ls = (3 - ts) % 3; // post conv lead size in bytes
         const wad = new Array(ws);
         wad.fill('A');
         const base = wad.join('') + bext; // pre pad with wad of zeros in Base64 == 'A'
-        const raw = Base64.decode(base); // [ls:]  // convert and remove leader
-
+        const raw = decodeBase64Url(base); // [ls:]  // convert and remove leader
         return Uint8Array.from(raw).subarray(ls); // raw binary equivalent of text
     }
-
-    get bext(): string {
+    get bext() {
         const sizage = Matter.Sizes.get(this.code);
-        const wad = Uint8Array.from(new Array(sizage?.ls).fill(0));
-        const bext = Base64.encode(Buffer.from([...wad, ...this.raw]));
-
+        const wad = Uint8Array.from(new Array(sizage === null || sizage === void 0 ? void 0 : sizage.ls).fill(0));
+        const bext = encodeBase64Url(concat(wad, this.raw));
         let ws = 0;
-        if (sizage?.ls === 0 && bext !== undefined) {
+        if ((sizage === null || sizage === void 0 ? void 0 : sizage.ls) === 0 && bext !== undefined) {
             if (bext[0] === 'A') {
                 ws = 1;
             }
-        } else {
-            ws = (sizage?.ls! + 1) % 4;
         }
-
+        else {
+            ws = ((sizage === null || sizage === void 0 ? void 0 : sizage.ls) + 1) % 4;
+        }
         return bext.substring(ws);
     }
 }

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

@@ -1,5 +1,5 @@
-import { Verfer } from './verfer';
-import { Matter, MatterArgs } from './matter';
+import { Verfer } from './verfer.ts';
+import { Matter, MatterArgs } from './matter.ts';
 export declare class Cigar extends Matter {
     private _verfer;
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer);

package/dist/keri/core/cigar.js

@@ -0,0 +1,13 @@
+import { Matter } from "./matter.js";
+export class Cigar extends Matter {
+    constructor({ raw, code, qb64, qb64b, qb2 }, verfer) {
+        super({ raw, code, qb64, qb64b, qb2 });
+        this._verfer = verfer;
+    }
+    get verfer() {
+        return this._verfer;
+    }
+    set verfer(verfer) {
+        this._verfer = verfer;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 export declare class Cipher extends Matter {
     constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
     decrypt(prikey?: Uint8Array | undefined, seed?: Uint8Array | undefined): any;

package/{src/keri/core/cipher.ts → dist/keri/core/cipher.js}

@@ -1,33 +1,24 @@
-import { Matter, MatterArgs, MtrDex } from './matter';
-import { Decrypter } from './decrypter';
-
+import { Matter, MtrDex } from "./matter.js";
+import { Decrypter } from "./decrypter.js";
 export class Cipher extends Matter {
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs) {
+    constructor({ raw, code, qb64, qb64b, qb2 }) {
         if (raw != undefined && code == undefined) {
             if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Salt)) {
                 code = MtrDex.X25519_Cipher_Salt;
-            } else if (
-                raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)
-            ) {
+            }
+            else if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)) {
                 code = MtrDex.X25519_Cipher_Salt;
             }
         }
         super({ raw: raw, code: code, qb64b: qb64b, qb64: qb64, qb2: qb2 });
-
-        if (
-            !Array.from([
-                MtrDex.X25519_Cipher_Salt,
-                MtrDex.X25519_Cipher_Seed,
-            ]).includes(this.code)
-        ) {
+        if (!Array.from([
+            MtrDex.X25519_Cipher_Salt,
+            MtrDex.X25519_Cipher_Seed,
+        ]).includes(this.code)) {
             throw new Error(`Unsupported Cipher code == ${this.code}`);
         }
     }
-
-    decrypt(
-        prikey: Uint8Array | undefined = undefined,
-        seed: Uint8Array | undefined = undefined
-    ) {
+    decrypt(prikey = undefined, seed = undefined) {
         const decrypter = new Decrypter({ qb64b: prikey }, seed);
         return decrypter.decrypt(this.qb64b);
     }

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

@@ -1,16 +1,31 @@
+/**
+ * Serialization types supported by the KERI and ACDC protocols and this Signify implementation.
+ */
 export declare enum Serials {
     JSON = "JSON"
 }
-export declare enum Ident {
+/**
+ * Protocol types supported by the KERI and ACDC protocols and this Signify implementation.
+ */
+export declare enum Protocols {
     KERI = "KERI",
     ACDC = "ACDC"
 }
+/**
+ * Represents a protocol version of the KERI, ACDC, or other protocol specified in a CESR version string.
+ */
 export declare class Version {
     major: number;
     minor: number;
     constructor(major?: number, minor?: number);
 }
-export declare const Versionage: Version;
+/**
+ * Denotes version 1.0 of a protocol.
+ */
+export declare const Vrsn_1_0: Version;
+/**
+ * Types of KERI and ACDC events.
+ */
 export declare const Ilks: {
     icp: string;
     rot: string;
@@ -24,36 +39,129 @@ export declare const Ilks: {
     vcp: string;
     iss: string;
     rev: string;
+    bis: string;
+    brv: string;
 };
+/**
+ * Field labels for an inception event in V1 of the KERI protocol.
+ */
 export declare const IcpLabels: string[];
+/**
+ * Field labels for an delegated inception event in V1 of the KERI protocol.
+ */
 export declare const DipLabels: string[];
+/**
+ * Field labels for a rotation event in V1 of the KERI protocol.
+ */
 export declare const RotLabels: string[];
+/**
+ * Field labels for an delegated rotation event in V1 of the KERI protocol.
+ */
 export declare const DrtLabels: string[];
+/**
+ * Field labels for an interaction event in V1 of the KERI protocol.
+ */
 export declare const IxnLabels: string[];
+/**
+ * Field labels for a key state notice event in V1 of the KERI protocol.
+ */
 export declare const KsnLabels: string[];
+/**
+ * Field labels for a reply event in V1 of the KERI protocol.
+ */
 export declare const RpyLabels: string[];
+/**
+ * Full size of a CESR version string in bytes.
+ */
 export declare const VERFULLSIZE = 17;
+/**
+ * Minimum number of bytes a CESR parser must sniff to receive the entire version string.
+ */
 export declare const MINSNIFFSIZE: number;
 export declare const MINSIGSIZE = 4;
+/**
+ * Regular expression for a version 1 CESR object version string.
+ */
 export declare const VEREX = "(KERI|ACDC)([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_";
+/**
+ * An interface for a basic dictionary type keyed by string with any value type.
+ * Mimics the Python dictionary type.
+ */
 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
+ * Parses a serialization version string into the protocol, protocol version, serialization type, and raw size.
+ * Uses regex matchers to validate and extract version string parts.
+ * @param {string} versionString version string
+ * @return {Object} tuple of prototol (KERI or ACDC), kind of serialization like cbor,json, or mgpk,
+ *                  protocol version, and raw size of serialization
+ */
+export declare function deversify(versionString: string): [Protocols, Serials, Version, string];
+/**
+ * Returns a valid KERI serialization version string specifying the protocol,
+ * protocol version, serialization type, and raw byte size of the serialization.
+ *
+ * Defaults to version 1.0.
+ * @param ident
+ * @param version
+ * @param kind
+ * @param size
+ */
+export declare function versify(ident?: Protocols, version?: Version, kind?: Serials, size?: number): string;
+/**
+ * Map allowing lookup of Base64URLSafe characters by index.
  */
-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>;
+/**
+ * Map allowing lookup of Base64URLSafe index by character.
+ */
 export declare const B64IdxByChr: Map<string, number>;
+/**
+ * Converts an integer to a Base64URLSafe encoded string, left padded as specified.
+ * @param i integer to convert
+ * @param l minimum length of Base64 digits left padded with Base64 0 == 'A' character.
+ */
 export declare function intToB64(i: number, l?: number): string;
+/**
+ * Converts an integer to a Base64URLSafe encoded string to a byte array, left padded as specified.
+ * @param i integer to convert
+ * @param l minimum length of Base64 digits left padded with Base64 0 == 'A' character.
+ */
 export declare function intToB64b(n: number, l?: number): Uint8Array;
+/**
+ * Converts a Base64URLSafe encoded string to an integer.
+ * @param s string to convert
+ */
 export declare function b64ToInt(s: string): number;
+/**
+ * Converts a UTF-8 string to bytes.
+ * Output is an encoded array of bytes. Assumes UTF-8 encoding.
+ * @param s string to be encoded as an array of bytes
+ */
 export declare function b(s?: string): Uint8Array;
+/**
+ * Convert bytes to UTF-8 string.
+ * @param u array of bytes to be converted to UTF-8 string.
+ */
 export declare function d(u?: Uint8Array): string;
+/**
+ * Concatenates two byte arrays together in a new byte array.
+ * @param one first byte array to be concatenated
+ * @param two second byte array to be concatenated
+ */
 export declare function concat(one: Uint8Array, two: Uint8Array): Uint8Array;
+/**
+ * Converts a big-endian byte array into an integer.
+ *
+ * @param array - A `Uint8Array` of bytes representing a big-endian integer.
+ * @returns The integer represented by the byte array.
+ *
+ * Example:
+ *   readInt(Uint8Array([0x01, 0x02, 0x03])) // returns 66051
+ *
+ * How it works:
+ * - The function interprets the array as a big-endian number.
+ * - Each byte is added to the integer after shifting the previous value left by 8 bits (multiplying by 256).
+ */
 export declare function readInt(array: Uint8Array): number;