signify-ts 0.1.1 → 0.2.1

package/src/keri/core/vdring.ts

@@ -0,0 +1,94 @@
+import { randomNonce } from '../app/coring';
+import { TraitDex } from '../app/habery';
+import {
+    Serials,
+    Versionage,
+    Version,
+    Ident,
+    versify,
+    Ilks,
+} from '../core/core';
+import { ample } from './eventing';
+import { MtrDex } from './matter';
+import { Prefixer } from './prefixer';
+import { Serder } from './serder';
+
+namespace vdr {
+    export interface VDRInceptArgs {
+        pre: string;
+        toad?: number | string;
+        nonce?: string;
+        baks?: string[];
+        cnfg?: string[];
+        version?: Version;
+        kind?: Serials;
+        code?: string;
+    }
+
+    export function incept({
+        pre,
+        toad,
+        nonce = randomNonce(),
+        baks = [],
+        cnfg = [],
+        version = Versionage,
+        kind = Serials.JSON,
+        code = MtrDex.Blake3_256,
+    }: VDRInceptArgs): Serder {
+        const vs = versify(Ident.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: number;
+        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 ked = {
+            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 }, ked);
+        ked.i = prefixer.qb64;
+        ked.d = prefixer.qb64;
+
+        return new Serder(ked);
+    }
+}
+
+export { vdr };

package/src/keri/core/verfer.ts

@@ -1,7 +1,7 @@
 export {};
-import libsodium from "libsodium-wrappers-sumo"
-
-import {Matter, MatterArgs, MtrDex} from './matter';
+import libsodium from 'libsodium-wrappers-sumo';
+import { Matter, MatterArgs, MtrDex } from './matter';
+import secp256r1 from 'ecdsa-secp256r1';
 
 /**
  * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
@@ -9,24 +9,37 @@ import {Matter, MatterArgs, MtrDex} from './matter';
  */
 export class Verfer extends Matter {
     private readonly _verify: (sig: any, ser: any, key: any) => boolean;
-    constructor({raw, code, qb64, qb64b, qb2}: MatterArgs) {
-        super({raw, code, qb64, qb64b, qb2});
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs) {
+        super({ raw, code, qb64, qb64b, qb2 });
 
         if (Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(this.code)) {
-            this._verify = this._ed25519
+            this._verify = this._ed25519;
+        } else if (
+            Array.from([MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256r1]).includes(
+                this.code
+            )
+        ) {
+            this._verify = this._secp256r1;
         } else {
-            throw new Error(`Unsupported code = ${this.code} for verifier.`)
+            throw new Error(`Unsupported code = ${this.code} for verifier.`);
         }
     }
 
     verify(sig: any, ser: any) {
-        return this._verify(sig, ser, this.raw)
+        return this._verify(sig, ser, this.raw);
     }
 
     _ed25519(sig: any, ser: any, key: any) {
         try {
             return libsodium.crypto_sign_verify_detached(sig, ser, key);
-
+        } catch (error) {
+            throw new Error(error as string);
+        }
+    }
+    _secp256r1(sig: any, ser: any, key: any) {
+        try {
+            const publicKey = secp256r1.fromCompressedPublicKey(key);
+            return publicKey.verify(ser, sig);
         } catch (error) {
             throw new Error(error as string);
         }

package/src/keri/end/ending.ts

@@ -1,160 +1,170 @@
-import {Siger} from "../core/siger";
-import {Cigar} from "../core/cigar";
+import { Siger } from '../core/siger';
+import { Cigar } from '../core/cigar';
 
-export const FALSY = [false, 0, "?0", "no", "false", "False", "off"]
-export const TRUTHY = [true, 1, "?1", "yes", "true", "True", 'on']
+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: any, indexed?: boolean, signer?: string, ordinal?: string,
-                digest?: string, kind?: string) {
-        this.markers = markers
-        this.indexed = indexed
-        this.signer = signer
-        this.ordinal = ordinal
-        this.digest = digest
-        this.kind = kind
+    constructor(
+        markers: any,
+        indexed?: boolean,
+        signer?: string,
+        ordinal?: string,
+        digest?: string,
+        kind?: string
+    ) {
+        this.markers = markers;
+        this.indexed = indexed;
+        this.signer = signer;
+        this.ordinal = ordinal;
+        this.digest = digest;
+        this.kind = kind;
     }
-    public markers: any
-    public indexed: boolean | undefined = false
-    public signer: string | undefined
-    public ordinal: string | undefined
-    public digest: string | undefined
-    public kind: string | undefined
+    public markers: any;
+    public indexed: boolean | undefined = false;
+    public signer: string | undefined;
+    public ordinal: string | undefined;
+    public digest: string | undefined;
+    public kind: string | undefined;
 }
 
 export function signature(signages: Array<Signage>): Headers {
-    let values = new Array<string>()
+    const values = new Array<string>();
 
-    for (let signage of signages) {
-        let markers: Array<Siger | Cigar>
-        let indexed = signage.indexed
-        let signer = signage.signer
-        let ordinal = signage.ordinal
-        let digest = signage.digest
-        let kind = signage.kind
-        let tags: Array<string>
+    for (const signage of signages) {
+        let markers: Array<Siger | Cigar>;
+        let indexed = signage.indexed;
+        const signer = signage.signer;
+        const ordinal = signage.ordinal;
+        const digest = signage.digest;
+        const kind = signage.kind;
+        let tags: Array<string>;
 
         if (signage.markers instanceof Map) {
-            tags = Array.from(signage.markers.keys())
-            markers = Array.from(signage.markers.values())
+            tags = Array.from(signage.markers.keys());
+            markers = Array.from(signage.markers.values());
         } else {
-            markers = signage.markers as Array<Siger | Cigar>
-            tags = new Array<string>()
+            markers = signage.markers as Array<Siger | Cigar>;
+            tags = new Array<string>();
         }
 
         if (indexed == undefined) {
-            indexed = markers[0] instanceof Siger
+            indexed = markers[0] instanceof Siger;
         }
 
-        let items = new Array<string>()
-        let tag = "indexed"
+        const items = new Array<string>();
+        const tag = 'indexed';
 
-        let val = indexed ? "?1" : "?0"
-        items.push(`${tag}="${val}"`)
+        let val = indexed ? '?1' : '?0';
+        items.push(`${tag}="${val}"`);
 
         if (signer != undefined) {
-            items.push(`signer="${signer}"`)
+            items.push(`signer="${signer}"`);
         }
         if (ordinal != undefined) {
-            items.push(`ordinal="${ordinal}"`)
+            items.push(`ordinal="${ordinal}"`);
         }
         if (digest != undefined) {
-            items.push(`digest="${digest}"`)
+            items.push(`digest="${digest}"`);
         }
         if (kind != undefined) {
-            items.push(`kind="${kind}"`)
+            items.push(`kind="${kind}"`);
         }
 
         markers.forEach((marker, idx) => {
-            let tag: string
-            if (tags != undefined) {
-                tag = tags[idx]
-            }
-
-            if (marker instanceof Siger) {
+            let tag: string;
+            if (tags != undefined && tags.length > idx) {
+                tag = tags[idx];
+            } else if (marker instanceof Siger) {
                 if (!indexed)
-                    throw new Error(`Indexed signature marker ${marker} when indexed False.`)
+                    throw new Error(
+                        `Indexed signature marker ${marker} when indexed False.`
+                    );
 
-                tag = marker.index.toString()
-            } else {  // Must be a Cigar
+                tag = marker.index.toString();
+            } else {
+                // Must be a Cigar
                 if (indexed)
-                    throw new Error(`Unindexed signature marker ${marker} when indexed True.`)
-                tag = marker.verfer!.qb64
+                    throw new Error(
+                        `Unindexed signature marker ${marker} when indexed True.`
+                    );
+                tag = marker.verfer!.qb64;
             }
 
-            val = marker.qb64
-            items.push(`${tag}="${val}"`)
-        })
+            val = marker.qb64;
+            items.push(`${tag}="${val}"`);
+        });
 
-        values.push(items.join(";"))
+        values.push(items.join(';'));
     }
 
-    return new Headers([
-        ["Signature", values.join(",")]
-    ])
+    return new Headers([['Signature', values.join(',')]]);
 }
 
 export function designature(value: string) {
-    let values = value.replace(" ", "").split(",")
+    const values = value.replace(' ', '').split(',');
 
-    let signages = new Array<Signage>()
+    const signages = new Array<Signage>();
     values.forEach((val) => {
-        let dict = new Map<string, string>()
-        val.split(";").forEach((v) => {
-            let 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 dict = new Map<string, string>();
+        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.'
+            );
         }
-        let item = dict.get("indexed")!
-        let indexed = !(FALSY.includes(item))
-        dict.delete("indexed")
-
-        let signer
-        if (dict.has("signer")) {
-            signer = dict.get("signer") as string
-            dict.delete("signer")
+        const item = dict.get('indexed')!;
+        const indexed = !FALSY.includes(item);
+        dict.delete('indexed');
+
+        let signer;
+        if (dict.has('signer')) {
+            signer = dict.get('signer') as string;
+            dict.delete('signer');
         }
 
-        let ordinal
-        if (dict.has("ordinal")) {
-            ordinal = dict.get("ordinal") as string
-            dict.delete("ordinal")
+        let ordinal;
+        if (dict.has('ordinal')) {
+            ordinal = dict.get('ordinal') as string;
+            dict.delete('ordinal');
         }
 
-        let digest
-        if (dict.has("digest")) {
-            digest = dict.get("digest") as string
-            dict.delete("digest")
+        let digest;
+        if (dict.has('digest')) {
+            digest = dict.get('digest') as string;
+            dict.delete('digest');
         }
 
-        let kind
-        if (dict.has("kind")) {
-            kind = dict.get("kind") as string
-            dict.delete("kind")
+        let kind;
+        if (dict.has('kind')) {
+            kind = dict.get('kind') as string;
+            dict.delete('kind');
         } else {
-            kind = "CESR"
+            kind = 'CESR';
         }
 
-        let markers: Map<string, string|Siger|Cigar>
-        if (kind == "CESR") {
-            markers = new Map<string, Siger|Cigar>()
+        let markers: Map<string, string | Siger | Cigar>;
+        if (kind == 'CESR') {
+            markers = new Map<string, Siger | Cigar>();
             dict.forEach((val, key) => {
                 if (indexed) {
-                    markers.set(key, new Siger({qb64: val as string}))
+                    markers.set(key, new Siger({ qb64: val as string }));
                 } else {
-                    markers.set(key, new Cigar({qb64: val as string}))
+                    markers.set(key, new Cigar({ qb64: val as string }));
                 }
-            })
+            });
         } else {
-            markers = dict
+            markers = dict;
         }
 
-        signages.push(new Signage(markers, indexed, signer, ordinal, digest, kind))
+        signages.push(
+            new Signage(markers, indexed, signer, ordinal, digest, kind)
+        );
+    });
 
-    })
-
-    return signages
-}
+    return signages;
+}

package/src/math.ts

@@ -0,0 +1,3 @@
+import { create, all } from 'mathjs';
+const config = {};
+export const math = create(all, config);

package/src/ready.ts

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

package/dist/keri/app/accountant.d.ts

@@ -1,10 +0,0 @@
-import { Manager } from "../core/manager";
-export declare class Accountant {
-    private readonly _agentKey;
-    private readonly _mgr;
-    private readonly _ready;
-    constructor(mgr: Manager, agentKey: string);
-    get ready(): Promise<void>;
-    sign(): Manager;
-    verify(): string;
-}

package/dist/keri/app/apping.d.ts

@@ -1 +0,0 @@
-export declare function randomPasscode(): string;

package/dist/keri/app/client.d.ts

@@ -1,7 +0,0 @@
-export declare class Client {
-    private readonly _url;
-    constructor(url: string);
-    url(path: string): string;
-    getAccount(name: string): Promise<Response>;
-    createAccount(name: string, key: string, ndig: string): Promise<Response>;
-}

package/dist/keri/app/signify.d.ts

@@ -1,6 +0,0 @@
-export declare class Signify {
-    private readonly _hby?;
-    private readonly _act?;
-    private readonly _client?;
-    constructor(url: string, name: string, passcode: string);
-}

package/src/keri/app/accountant.ts

@@ -1,35 +0,0 @@
-import {Manager} from "../core/manager";
-
-
-export class Accountant {
-    private readonly _agentKey: string
-    private readonly _mgr: Manager
-    private readonly _ready: Promise<void>
-
-    /*
-    *   Accountant is responsible for managing signing keys for the client and agent.  The client
-    *   signing key represents the Account for the client on the agent
-    *
-    */
-    constructor(mgr: Manager, agentKey: string) {
-        this._mgr = mgr
-        this._agentKey = agentKey
-        this._ready = new Promise<void>(()=>{})
-    }
-
-    get ready(): Promise<void> {
-        return this._ready
-    }
-
-
-    sign() {
-        return this._mgr
-
-    }
-
-    verify() {
-        return this._agentKey
-    }
-
-
-}

package/src/keri/app/apping.ts

@@ -1,12 +0,0 @@
-import libsodium from "libsodium-wrappers-sumo";
-import {Salter} from "../core/salter";
-
-
-export function randomPasscode(): string {
-    let raw = libsodium.randombytes_buf(16);
-    let salter = new Salter({raw: raw})
-
-    return salter.qb64.substring(2)
-}
-
-

package/src/keri/app/client.ts

@@ -1,30 +0,0 @@
-
-
-export class Client {
-    private readonly _url: string
-
-    constructor(url: string) {
-        this._url = url
-    }
-
-    url(path: string): string {
-        let url = new URL(path, this._url)
-
-        return url.href
-    }
-
-    getAccount(name: string): Promise<Response> {
-        let url = this.url(`/account/${name}`)
-        let req = new Request(url, {method: "GET"})
-        return fetch(req)
-    }
-
-    createAccount(name: string, key: string, ndig: string): Promise<Response> {
-        let url = this.url(`/account/${name}`)
-        let body = {key, ndig}
-        let req = new Request(url, {method: "POST", body: JSON.stringify(body)})
-        return fetch(req)
-    }
-
-
-}

package/src/keri/app/signify.ts

@@ -1,12 +0,0 @@
-import {Habery} from "./habery";
-import {Accountant} from "./accountant";
-import {Client} from "./client";
-
-
-export class Signify {
-    private readonly _hby?: Habery
-    private readonly _act?: Accountant
-    private readonly _client?: Client
-    constructor(url:string, name:string, passcode: string) {
-    }
-}