signify-ts 0.2.0 → 0.3.0-dev.e31e78d

package/src/keri/core/signer.ts

@@ -1,133 +0,0 @@
-import { EmptyMaterialError } from './kering';
-
-export {};
-import libsodium from 'libsodium-wrappers-sumo';
-import { Matter } from './matter';
-import { MtrDex } from './matter';
-import { Verfer } from './verfer';
-import { Cigar } from './cigar';
-import { Siger } from './siger';
-import { IdrDex } from './indexer';
-import { Buffer } from 'buffer';
-
-/**
- * @description Signer is Matter subclass with method to create signature of serialization
- * It will use .raw as signing (private) key seed
- * .code as cipher suite for signing and new property .verfer whose property
- *  .raw is public key for signing.
- *  If not provided .verfer is generated from private key seed using .code
- as cipher suite for creating key-pair.
- */
-interface SignerArgs {
-    raw?: Uint8Array | undefined;
-    code?: string;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string;
-    qb2?: Uint8Array | undefined;
-    transferable?: boolean;
-}
-
-export class Signer extends Matter {
-    private readonly _sign: Function;
-    private readonly _verfer: Verfer;
-
-    constructor({
-        raw,
-        code = MtrDex.Ed25519_Seed,
-        qb64,
-        qb64b,
-        qb2,
-        transferable = true,
-    }: SignerArgs) {
-        try {
-            super({ raw, code, qb64, qb64b, qb2 });
-        } catch (e) {
-            if (e instanceof EmptyMaterialError) {
-                if (code == MtrDex.Ed25519_Seed) {
-                    const raw = libsodium.randombytes_buf(
-                        libsodium.crypto_sign_SEEDBYTES
-                    );
-                    super({ raw, code, qb64, qb64b, qb2 });
-                } else {
-                    throw new Error(`Unsupported signer code = ${code}.`);
-                }
-            } else {
-                throw e;
-            }
-        }
-        let verfer;
-        if (this.code == MtrDex.Ed25519_Seed) {
-            this._sign = this._ed25519;
-            const keypair = libsodium.crypto_sign_seed_keypair(this.raw);
-            verfer = new Verfer({
-                raw: keypair.publicKey,
-                code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N,
-            });
-        } else {
-            throw new Error(`Unsupported signer code = ${this.code}.`);
-        }
-
-        this._verfer = verfer;
-    }
-
-    /**
-     * @description Property verfer:
-     Returns Verfer instance
-     Assumes ._verfer is correctly assigned
-     */
-    get verfer(): Verfer {
-        return this._verfer;
-    }
-
-    sign(
-        ser: Uint8Array,
-        index: number | null = null,
-        only: boolean = false,
-        ondex: number | undefined = undefined
-    ): Siger | Cigar {
-        return this._sign(ser, this.raw, this.verfer, index, only, ondex);
-    }
-
-    _ed25519(
-        ser: Uint8Array,
-        seed: Uint8Array,
-        verfer: Verfer,
-        index: number | null,
-        only: boolean = false,
-        ondex: number | undefined
-    ) {
-        const sig = libsodium.crypto_sign_detached(
-            ser,
-            Buffer.concat([seed, verfer.raw])
-        );
-
-        if (index == null) {
-            return new Cigar({ raw: sig, code: MtrDex.Ed25519_Sig }, verfer);
-        } else {
-            let code;
-            if (only) {
-                ondex = undefined;
-                if (index <= 63) {
-                    code = IdrDex.Ed25519_Crt_Sig;
-                } else {
-                    code = IdrDex.Ed25519_Big_Crt_Sig;
-                }
-            } else {
-                if (ondex == undefined) {
-                    ondex = index;
-                }
-
-                if (ondex == index && index <= 63)
-                    // both same and small
-                    code = IdrDex.Ed25519_Sig; //  use  small both same
-                //  otherwise big or both not same so use big both
-                else code = IdrDex.Ed25519_Big_Sig; // use use big both
-            }
-
-            return new Siger(
-                { raw: sig, code: code, index: index, ondex: ondex },
-                verfer
-            );
-        }
-    }
-}

package/src/keri/core/vdring.ts

@@ -1,94 +0,0 @@
-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,47 +0,0 @@
-export {};
-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
- *  using .raw as verifier key and .code as signature cypher suite
- */
-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 });
-
-        if (Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(this.code)) {
-            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.`);
-        }
-    }
-
-    verify(sig: any, ser: any) {
-        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,170 +0,0 @@
-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 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;
-    }
-    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 {
-    const values = new 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());
-        } else {
-            markers = signage.markers as Array<Siger | Cigar>;
-            tags = new Array<string>();
-        }
-
-        if (indexed == undefined) {
-            indexed = markers[0] instanceof Siger;
-        }
-
-        const items = new Array<string>();
-        const tag = 'indexed';
-
-        let val = indexed ? '?1' : '?0';
-        items.push(`${tag}="${val}"`);
-
-        if (signer != undefined) {
-            items.push(`signer="${signer}"`);
-        }
-        if (ordinal != undefined) {
-            items.push(`ordinal="${ordinal}"`);
-        }
-        if (digest != undefined) {
-            items.push(`digest="${digest}"`);
-        }
-        if (kind != undefined) {
-            items.push(`kind="${kind}"`);
-        }
-
-        markers.forEach((marker, idx) => {
-            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.`
-                    );
-
-                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;
-            }
-
-            val = marker.qb64;
-            items.push(`${tag}="${val}"`);
-        });
-
-        values.push(items.join(';'));
-    }
-
-    return new Headers([['Signature', values.join(',')]]);
-}
-
-export function designature(value: string) {
-    const values = value.replace(' ', '').split(',');
-
-    const signages = new Array<Signage>();
-    values.forEach((val) => {
-        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.'
-            );
-        }
-        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 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');
-        } else {
-            kind = 'CESR';
-        }
-
-        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 }));
-                } else {
-                    markers.set(key, new Cigar({ qb64: val as string }));
-                }
-            });
-        } else {
-            markers = dict;
-        }
-
-        signages.push(
-            new Signage(markers, indexed, signer, ordinal, digest, kind)
-        );
-    });
-
-    return signages;
-}

package/src/math.ts

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