signify-ts 0.2.0 → 0.3.0-dev.e31e78d

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

@@ -1,14 +1,10 @@
-import { Counter, CtrDex } from './counter';
-import { Seqner } from './seqner';
-import { Prefixer } from './prefixer';
-import { Saider } from './saider';
-import { Serder } from './serder';
-import { b } from './core';
-
-export function pad(n: any, width = 3, z = 0) {
+import { Counter, CtrDex } from "./counter.js";
+import { Seqner } from "./seqner.js";
+import { Prefixer } from "./prefixer.js";
+import { Saider } from "./saider.js";
+export function pad(n, width = 3, z = 0) {
     return (String(z).repeat(width) + String(n)).slice(String(n).length);
 }
-
 /**
  * @description  Returns list of depth first recursively extracted values from elements of
     key event dict ked whose flabels are in lables list
@@ -16,22 +12,17 @@ export function pad(n: any, width = 3, z = 0) {
  * @param {*} ked  ked is key event dict
  * @param {*} labels    labels is list of element labels in ked from which to extract values
  */
-export function extractValues(ked: any, labels: any) {
+export function extractValues(ked, labels) {
     let values = [];
     for (const label of labels) {
         values = extractElementValues(ked[label], values);
     }
-
     return values;
 }
-
-export function arrayEquals(ar1: Uint8Array, ar2: Uint8Array) {
-    return (
-        ar1.length === ar2.length &&
-        ar1.every((val, index) => val === ar2[index])
-    );
+export function arrayEquals(ar1, ar2) {
+    return (ar1.length === ar2.length &&
+        ar1.every((val, index) => val === ar2[index]));
 }
-
 /**
  * @description   Recusive depth first search that recursively extracts value(s) from element
     and appends to values list
@@ -40,65 +31,55 @@ export function arrayEquals(ar1: Uint8Array, ar2: Uint8Array) {
  * @param {*} element
  * @param {*} values
  */
-
-function extractElementValues(element: any, values: any) {
+function extractElementValues(element, values) {
     let data = [];
-
     try {
         if (element instanceof Array && !(typeof element == 'string')) {
-            for (const k in element) extractElementValues(element[k], values);
-        } else if (typeof element == 'string') {
+            for (const k in element)
+                extractElementValues(element[k], values);
+        }
+        else if (typeof element == 'string') {
             values.push(element);
         }
         data = values;
-    } catch (error) {
-        throw new Error(error as string);
     }
-
+    catch (error) {
+        throw new Error(error);
+    }
     return data;
 }
-
 /**
  * @description Returns True if obj is non-string iterable, False otherwise
 
  * @param {*} obj
  */
-
 // function nonStringIterable(obj) {
 //     obj instanceof (String)
 //     return  instanceof(obj, (str, bytes)) && instanceof(obj, Iterable))
 // }
-
-export function nowUTC(): Date {
+export function nowUTC() {
     return new Date();
 }
-
-export function range(start: number, stop: number, step: number) {
+export function range(start, stop, step) {
     if (typeof stop == 'undefined') {
         // one param defined
         stop = start;
         start = 0;
     }
-
     if (typeof step == 'undefined') {
         step = 1;
     }
-
     if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
         return [];
     }
-
-    const result = new Array<number>();
-    for (let i: number = start; step > 0 ? i < stop : i > stop; i += step) {
+    const result = new Array();
+    for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
         result.push(i);
     }
-
     return result;
 }
-
-export function intToBytes(value: number, length: number): Uint8Array {
+export function intToBytes(value, length) {
     const byteArray = new Uint8Array(length); // Assuming a 4-byte integer (32 bits)
-
     for (let index = byteArray.length - 1; index >= 0; index--) {
         const byte = value & 0xff;
         byteArray[index] = byte;
@@ -106,27 +87,23 @@ export function intToBytes(value: number, length: number): Uint8Array {
     }
     return byteArray;
 }
-
-export function bytesToInt(ar: Uint8Array): number {
+export function bytesToInt(ar) {
     let value = 0;
     for (let i = 0; i < ar.length; i++) {
         value = value * 256 + ar[i];
     }
     return value;
 }
-
-export function serializeACDCAttachment(anc: Serder): Uint8Array {
+export function serializeACDCAttachment(anc) {
     const prefixer = new Prefixer({ qb64: anc.pre });
     const seqner = new Seqner({ sn: anc.sn });
-    const saider = new Saider({ qb64: anc.ked['d'] });
+    const saider = new Saider({ qb64: anc.sad['d'] });
     const craw = new Uint8Array();
     const ctr = new Counter({ code: CtrDex.SealSourceTriples, count: 1 }).qb64b;
     const prefix = prefixer.qb64b;
     const seq = seqner.qb64b;
     const said = saider.qb64b;
-    const newCraw = new Uint8Array(
-        craw.length + ctr.length + prefix.length + seq.length + said.length
-    );
+    const newCraw = new Uint8Array(craw.length + ctr.length + prefix.length + seq.length + said.length);
     newCraw.set(craw);
     newCraw.set(ctr, craw.length);
     newCraw.set(prefix, craw.length + ctr.length);
@@ -134,13 +111,10 @@ export function serializeACDCAttachment(anc: Serder): Uint8Array {
     newCraw.set(said, craw.length + ctr.length + prefix.length + seq.length);
     return newCraw;
 }
-
-export function serializeIssExnAttachment(anc: Serder): Uint8Array {
+export function serializeIssExnAttachment(anc) {
     const seqner = new Seqner({ sn: anc.sn });
-    const ancSaider = new Saider({ qb64: anc.ked['d'] });
-    const coupleArray = new Uint8Array(
-        seqner.qb64b.length + ancSaider.qb64b.length
-    );
+    const ancSaider = new Saider({ qb64: anc.sad['d'] });
+    const coupleArray = new Uint8Array(seqner.qb64b.length + ancSaider.qb64b.length);
     coupleArray.set(seqner.qb64b);
     coupleArray.set(ancSaider.qb64b, seqner.qb64b.length);
     const counter = new Counter({
@@ -151,11 +125,8 @@ export function serializeIssExnAttachment(anc: Serder): Uint8Array {
     const atc = new Uint8Array(counter.qb64b.length + coupleArray.length);
     atc.set(counterQb64b);
     atc.set(coupleArray, counterQb64b.length);
-
     if (atc.length % 4 !== 0) {
-        throw new Error(
-            `Invalid attachments size: ${atc.length}, non-integral quadlets detected.`
-        );
+        throw new Error(`Invalid attachments size: ${atc.length}, non-integral quadlets detected.`);
     }
     const pcnt = new Counter({
         code: CtrDex.AttachedMaterialQuadlets,
@@ -164,6 +135,5 @@ export function serializeIssExnAttachment(anc: Serder): Uint8Array {
     const msg = new Uint8Array(pcnt.qb64b.length + atc.length);
     msg.set(pcnt.qb64b);
     msg.set(atc, pcnt.qb64b.length);
-
     return msg;
 }

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

@@ -1,5 +1,5 @@
-import { Serials, Version } from '../core/core';
-import { Serder } from './serder';
+import { Serials, Version } from '../core/core.ts';
+import { Serder } from './serder.ts';
 declare namespace vdr {
     interface VDRInceptArgs {
         pre: string;

package/dist/keri/core/vdring.js

@@ -0,0 +1,61 @@
+import { randomNonce } from "../app/coring.js";
+import { TraitDex } from "../app/habery.js";
+import { Serials, Vrsn_1_0, Protocols, versify, Ilks, } from "../core/core.js";
+import { ample } from "./eventing.js";
+import { MtrDex } from "./matter.js";
+import { Prefixer } from "./prefixer.js";
+import { Serder } from "./serder.js";
+var vdr;
+(function (vdr) {
+    function incept({ pre, toad, nonce = randomNonce(), baks = [], cnfg = [], version = Vrsn_1_0, kind = Serials.JSON, code = MtrDex.Blake3_256, }) {
+        const vs = versify(Protocols.KERI, version, kind, 0);
+        const isn = 0;
+        const ilk = Ilks.vcp;
+        if (cnfg.includes(TraitDex.NoBackers) && baks.length > 0) {
+            throw new Error(`${baks.length} backers specified for NB vcp, 0 allowed`);
+        }
+        if (new Set(baks).size < baks.length) {
+            throw new Error(`Invalid baks ${baks} has duplicates`);
+        }
+        let _toad;
+        if (toad === undefined) {
+            if (baks.length === 0) {
+                _toad = 0;
+            }
+            else {
+                _toad = ample(baks.length);
+            }
+        }
+        else {
+            _toad = +toad;
+        }
+        if (baks.length > 0) {
+            if (_toad < 1 || _toad > baks.length) {
+                throw new Error(`Invalid toad ${_toad} for baks in ${baks}`);
+            }
+        }
+        else {
+            if (_toad != 0) {
+                throw new Error(`Invalid toad ${_toad} for no baks`);
+            }
+        }
+        const sad = {
+            v: vs,
+            t: ilk,
+            d: '',
+            i: '',
+            ii: pre,
+            s: '' + isn,
+            c: cnfg,
+            bt: _toad.toString(16),
+            b: baks,
+            n: nonce,
+        };
+        const prefixer = new Prefixer({ code }, sad);
+        sad.i = prefixer.qb64;
+        sad.d = prefixer.qb64;
+        return new Serder(sad);
+    }
+    vdr.incept = incept;
+})(vdr || (vdr = {}));
+export { vdr };

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

@@ -1,13 +1,9 @@
-export {};
-import { Matter, MatterArgs } from './matter';
+import { Matter, MatterArgs } from './matter.ts';
 /**
  * @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;
+    verify(sig: Uint8Array, ser: Uint8Array | string): boolean;
 }

package/dist/keri/core/verfer.js

@@ -0,0 +1,37 @@
+import libsodium from 'libsodium-wrappers-sumo';
+import { Matter, MtrDex } from "./matter.js";
+import { p256 } from '@noble/curves/p256';
+import { b } from "./core.js";
+const VERFER_CODES = new Set([
+    MtrDex.Ed25519N,
+    MtrDex.Ed25519,
+    MtrDex.ECDSA_256r1N,
+    MtrDex.ECDSA_256r1,
+]);
+/**
+ * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
+ *  using .raw as verifier key and .code as signature cypher suite
+ */
+export class Verfer extends Matter {
+    constructor({ raw, code, qb64, qb64b, qb2 }) {
+        super({ raw, code, qb64, qb64b, qb2 });
+        if (!VERFER_CODES.has(this.code)) {
+            throw new Error(`Unsupported code = ${this.code} for verifier.`);
+        }
+    }
+    verify(sig, ser) {
+        switch (this.code) {
+            case MtrDex.Ed25519:
+            case MtrDex.Ed25519N: {
+                return libsodium.crypto_sign_verify_detached(sig, ser, this.raw);
+            }
+            case MtrDex.ECDSA_256r1:
+            case MtrDex.ECDSA_256r1N: {
+                const message = typeof ser === 'string' ? b(ser) : ser;
+                return p256.verify(sig, message, this.raw);
+            }
+            default:
+                throw new Error(`Unsupported code = ${this.code} for verifier.`);
+        }
+    }
+}

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

@@ -1,13 +1,15 @@
+import { Siger } from '../core/siger.ts';
+import { Cigar } from '../core/cigar.ts';
 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;
+    readonly markers: (Siger | Cigar)[] | Map<string, string | Siger | Cigar>;
+    readonly indexed?: boolean | undefined;
+    readonly signer?: string | undefined;
+    readonly ordinal?: string | undefined;
+    readonly digest?: string | undefined;
+    readonly kind?: string | undefined;
+    constructor(markers: (Siger | Cigar)[] | Map<string, string | Siger | Cigar>, 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 signature(signages: Signage[]): Headers;
 export declare function designature(value: string): Signage[];

package/dist/keri/end/ending.js

@@ -0,0 +1,136 @@
+import { Siger } from "../core/siger.js";
+import { Cigar } from "../core/cigar.js";
+export const FALSY = [false, 0, '?0', 'no', 'false', 'False', 'off'];
+export const TRUTHY = [true, 1, '?1', 'yes', 'true', 'True', 'on'];
+export class Signage {
+    constructor(markers, indexed, signer, ordinal, digest, kind) {
+        this.markers = markers;
+        this.indexed = indexed;
+        this.signer = signer;
+        this.ordinal = ordinal;
+        this.digest = digest;
+        this.kind = kind;
+    }
+}
+export function signature(signages) {
+    var _a;
+    const values = [];
+    for (const signage of signages) {
+        let markers;
+        let tags;
+        if (signage.markers instanceof Map) {
+            markers = Array.from(signage.markers.values());
+            tags = Array.from(signage.markers.keys());
+        }
+        else {
+            markers = signage.markers;
+            tags = [];
+        }
+        const items = new Array();
+        const indexed = (_a = signage.indexed) !== null && _a !== void 0 ? _a : markers[0] instanceof Siger;
+        if (indexed) {
+            items.push('indexed="?1"');
+        }
+        else {
+            items.push('indexed="?0"');
+        }
+        if (signage.signer != undefined) {
+            items.push(`signer="${signage.signer}"`);
+        }
+        if (signage.ordinal != undefined) {
+            items.push(`ordinal="${signage.ordinal}"`);
+        }
+        if (signage.digest != undefined) {
+            items.push(`digest="${signage.digest}"`);
+        }
+        if (signage.kind != undefined) {
+            items.push(`kind="${signage.kind}"`);
+        }
+        items.push(...markers.map((marker, idx) => {
+            let tag = undefined;
+            let val;
+            if (tags != undefined && tags.length > idx) {
+                tag = tags[idx];
+            }
+            if (marker instanceof Siger) {
+                if (!indexed) {
+                    throw new Error(`Indexed signature marker ${marker} when indexed False.`);
+                }
+                tag = tag !== null && tag !== void 0 ? tag : marker.index.toString();
+                val = marker.qb64;
+            }
+            else if (marker instanceof Cigar) {
+                if (indexed) {
+                    throw new Error(`Unindexed signature marker ${marker} when indexed True.`);
+                }
+                if (!marker.verfer) {
+                    throw new Error(`Indexed signature marker is missing verfer`);
+                }
+                tag = tag !== null && tag !== void 0 ? tag : marker.verfer.qb64;
+                val = marker.qb64;
+            }
+            else {
+                tag = tag !== null && tag !== void 0 ? tag : idx.toString();
+                val = marker;
+            }
+            return `${tag}="${val}"`;
+        }));
+        values.push(items.join(';'));
+    }
+    return new Headers([['Signature', values.join(',')]]);
+}
+export function designature(value) {
+    const values = value.replace(' ', '').split(',');
+    const signages = values.map((val) => {
+        const dict = new Map();
+        val.split(';').forEach((v) => {
+            const splits = v.split('=', 2);
+            dict.set(splits[0], splits[1].replaceAll('"', ''));
+        });
+        if (!dict.has('indexed')) {
+            throw new Error('Missing indexed field in Signature header signage.');
+        }
+        const item = dict.get('indexed');
+        const indexed = !FALSY.includes(item);
+        dict.delete('indexed');
+        let signer;
+        if (dict.has('signer')) {
+            signer = dict.get('signer');
+            dict.delete('signer');
+        }
+        let ordinal;
+        if (dict.has('ordinal')) {
+            ordinal = dict.get('ordinal');
+            dict.delete('ordinal');
+        }
+        let digest;
+        if (dict.has('digest')) {
+            digest = dict.get('digest');
+            dict.delete('digest');
+        }
+        let kind;
+        if (dict.has('kind')) {
+            kind = dict.get('kind');
+            dict.delete('kind');
+        }
+        else {
+            kind = 'CESR';
+        }
+        if (kind == 'CESR') {
+            const markers = new Map();
+            for (const [key, val] of dict.entries()) {
+                if (indexed) {
+                    markers.set(key, new Siger({ qb64: val }));
+                }
+                else {
+                    markers.set(key, new Cigar({ qb64: val }));
+                }
+            }
+            return new Signage(markers, indexed, signer, ordinal, digest, kind);
+        }
+        else {
+            return new Signage(dict, indexed, signer, ordinal, digest, kind);
+        }
+    });
+    return signages;
+}

package/{src/ready.ts → dist/ready.js}

@@ -1,5 +1,4 @@
 import _sodium from 'libsodium-wrappers-sumo';
-
-export const ready: () => Promise<void> = async () => {
+export const ready = async () => {
     await _sodium.ready;
 };