keri 0.0.0-dev.8b0703e → 0.0.0-dev.bf75350

package/dist/events/interact.d.ts

@@ -1,14 +0,0 @@
-import type { DataArray } from "../data-type.ts";
-export interface InteractArgs {
-    i: string;
-    s: string;
-    a: DataArray;
-}
-export interface InteractEvent {
-    v: string;
-    t: "ixn";
-    d: string;
-    i: string;
-    a: DataArray;
-}
-export declare function interact(data: InteractArgs): InteractEvent;

package/dist/events/interact.js

@@ -1,20 +0,0 @@
-import { blake3 } from "@noble/hashes/blake3";
-import cesr from "../parser/cesr-encoding.js";
-import { MatterCode } from "../parser/codes.js";
-import { versify } from "../parser/version.js";
-export function interact(data) {
-    const event = versify({
-        t: "ixn",
-        d: "#".repeat(44),
-        i: data.i,
-        s: data.s,
-        a: data.a,
-    });
-    const encoder = new TextEncoder();
-    const digest = cesr.encode(MatterCode.Blake3_256, blake3
-        .create({ dkLen: 32 })
-        .update(encoder.encode(JSON.stringify(event)))
-        .digest());
-    event["d"] = digest;
-    return event;
-}

package/dist/events/main.d.ts

@@ -1,4 +0,0 @@
-export * from "./common.ts";
-export * from "./incept.ts";
-export * from "./reply.ts";
-export * from "./interact.ts";

package/dist/events/main.js

@@ -1,4 +0,0 @@
-export * from "./common.js";
-export * from "./incept.js";
-export * from "./reply.js";
-export * from "./interact.js";

package/dist/events/reply.d.ts

@@ -1,15 +0,0 @@
-import type { DataObject } from "../data-type.ts";
-export interface ReplyArgs {
-    dt?: string;
-    r: string;
-    a: DataObject;
-}
-export interface ReplyEvent {
-    v: string;
-    t: "rpy";
-    d: string;
-    dt: string;
-    r: string;
-    a: DataObject;
-}
-export declare function reply(data: ReplyArgs): ReplyEvent;

package/dist/events/reply.js

@@ -1,20 +0,0 @@
-import { blake3 } from "@noble/hashes/blake3";
-import cesr from "../parser/cesr-encoding.js";
-import { MatterCode } from "../parser/codes.js";
-import { versify } from "../parser/version.js";
-export function reply(data) {
-    const event = versify({
-        t: "rpy",
-        d: "#".repeat(44),
-        dt: data.dt ?? new Date().toISOString(),
-        r: data.r,
-        a: data.a,
-    });
-    const encoder = new TextEncoder();
-    const digest = cesr.encode(MatterCode.Blake3_256, blake3
-        .create({ dkLen: 32 })
-        .update(encoder.encode(JSON.stringify(event)))
-        .digest());
-    event["d"] = digest;
-    return event;
-}

package/dist/keri.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/keri.js

@@ -1,110 +0,0 @@
-import { program } from "commander";
-import { parseStream } from "./parser/parser.js";
-import { CounterCode } from "./parser/codes.js";
-import { incept } from "./events/incept.js";
-import cesr from "./parser/cesr-encoding.js";
-import { encodeBase64Int } from "./parser/base64.js";
-import { FileSystemKeyStore } from "./keystore/keystore-fs.js";
-import { SqliteEventStore } from "./db/sqlite-db.js";
-const db = new SqliteEventStore({ filename: ".keri/db.sqlite" });
-db.init();
-program.command("parse").action(async () => {
-    const stream = process.stdin;
-    for await (const event of parseStream(ReadableStream.from(stream))) {
-        console.log(event);
-    }
-});
-program
-    .command("keygen")
-    .requiredOption("--passcode <passcode>")
-    .action(async ({ passcode }) => {
-    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
-    await keystore.incept();
-});
-program.command("resolve <oobi>").action(async (oobi) => {
-    const response = await fetch(oobi);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch oobi: ${response.status} ${response.statusText}`);
-    }
-    if (!response.body) {
-        throw new Error(`No body in response`);
-    }
-    for await (const event of parseStream(response.body)) {
-        db.insert(event.payload);
-    }
-});
-program
-    .command("incept")
-    .requiredOption("--passcode <passcode>")
-    .requiredOption("--name <name>")
-    .option("--wit <wit>")
-    .action(async ({ passcode, name, wit }) => {
-    if (typeof passcode !== "string") {
-        throw new Error(`Invalid passcode`);
-    }
-    if (typeof name !== "string") {
-        throw new Error(`Invalid name`);
-    }
-    const keystore = new FileSystemKeyStore({ dir: ".keri/keys", passphrase: passcode });
-    const keys = [await keystore.incept()];
-    const wits = [];
-    if (typeof wit === "string") {
-        wits.push(wit);
-    }
-    const payload = incept({
-        kt: "1",
-        k: keys.map((key) => key.current),
-        nt: "1",
-        n: keys.map((key) => key.next),
-        bt: "1",
-        b: wits,
-    });
-    const witnessEndpoints = await Promise.all(wits.map(async (wit) => {
-        const result = await db.locations(wit);
-        if (result.length === 0) {
-            throw new Error(`No location found for wit ${wit}`);
-        }
-        return result[0].a.url;
-    }));
-    const sigs = await Promise.all(keys.map(async (key, index) => {
-        const sig = await keystore.sign(key.current, new TextEncoder().encode(JSON.stringify(payload)));
-        return cesr.index(sig, index);
-    }));
-    const sigGroup = `${CounterCode.ControllerIdxSigs}${encodeBase64Int(sigs.length, 2)}${sigs.join("")}`;
-    const attachmentSize = new TextEncoder().encode(sigGroup).length / 4;
-    const attachment = `${CounterCode.AttachmentGroup}${encodeBase64Int(attachmentSize, 2)}${sigGroup}`;
-    for (const wit of witnessEndpoints) {
-        const url = new URL("/receipts", wit);
-        const response = await fetch(url, {
-            method: "POST",
-            body: JSON.stringify(payload),
-            headers: {
-                "Content-Type": "application/cesr+json",
-                "CESR-ATTACHMENT": attachment,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to send event to wit ${wit}: ${response.status} ${response.statusText}`);
-        }
-        if (response.status !== 200) {
-            throw new Error(`Failed to send event to wit ${wit}: ${response.status} ${response.statusText}`);
-        }
-        if (response.body) {
-            for await (const receipt of parseStream(response.body)) {
-                await db.insert(receipt.payload);
-                console.log(receipt);
-            }
-        }
-    }
-    console.dir({
-        payload: payload,
-        sigs,
-        attachment,
-    });
-});
-program.command("export").action(async () => {
-    for (const event of await db.list()) {
-        console.log(event);
-    }
-});
-program.parse(process.argv);

package/dist/keystore/keystore-fs.d.ts

@@ -1,13 +0,0 @@
-import type { KeyStore, Key } from "./keystore.ts";
-export interface FileSystemKeyStoreOptions {
-    dir: string;
-    passphrase: string;
-}
-export declare class FileSystemKeyStore implements KeyStore {
-    private readonly options;
-    constructor(options: FileSystemKeyStoreOptions);
-    private load;
-    incept(): Promise<Key>;
-    rotate(currentKey: string): Promise<Key>;
-    sign(publicKey: string, message: Uint8Array): Promise<string>;
-}

package/dist/keystore/keystore-fs.js

@@ -1,50 +0,0 @@
-import { ed25519 } from "@noble/curves/ed25519";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import cesr from "../parser/cesr-encoding.js";
-import { MatterCode } from "../parser/codes.js";
-import { decodeBase64, encodeBase64 } from "../parser/base64.js";
-import { decrypt, encrypt } from "./encrypt.js";
-import { join } from "node:path";
-import { blake3 } from "@noble/hashes/blake3";
-export class FileSystemKeyStore {
-    constructor(options) {
-        this.options = options;
-    }
-    async load(publicKey) {
-        const value = await readFile(join(this.options.dir, publicKey), "utf-8");
-        const [key0, key1] = value.split("\n");
-        return [
-            await decrypt(this.options.passphrase, decodeBase64(key0)),
-            await decrypt(this.options.passphrase, decodeBase64(key1)),
-        ];
-    }
-    async incept() {
-        const key0 = ed25519.utils.randomPrivateKey();
-        const key1 = ed25519.utils.randomPrivateKey();
-        await mkdir(this.options.dir, { recursive: true });
-        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
-        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
-        await writeFile(join(this.options.dir, current), [
-            encodeBase64(await encrypt(this.options.passphrase, key0)),
-            encodeBase64(await encrypt(this.options.passphrase, key1)),
-            "\n",
-        ].join("\n"));
-        return { current, next };
-    }
-    async rotate(currentKey) {
-        const [, key0] = await this.load(currentKey);
-        const key1 = ed25519.utils.randomPrivateKey();
-        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
-        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
-        await writeFile(join(this.options.dir, current), [
-            encodeBase64(await encrypt(this.options.passphrase, key0)),
-            encodeBase64(await encrypt(this.options.passphrase, key1)),
-            "\n",
-        ].join("\n"));
-        return { current, next };
-    }
-    async sign(publicKey, message) {
-        const [key] = await this.load(publicKey);
-        return cesr.sign(message, key, "ed25519");
-    }
-}

package/dist/keystore/keystore-web.d.ts

@@ -1,12 +0,0 @@
-import type { Key, KeyStore } from "./keystore.ts";
-export interface WebKeyStoreOptions {
-    passphrase: string;
-}
-export declare class WebKeyStore implements KeyStore {
-    private readonly options;
-    constructor(options: WebKeyStoreOptions);
-    private load;
-    incept(): Promise<Key>;
-    rotate(currentKey: string): Promise<Key>;
-    sign(publicKey: string, message: Uint8Array): Promise<string>;
-}

package/dist/keystore/keystore-web.js

@@ -1,48 +0,0 @@
-import { ed25519 } from "@noble/curves/ed25519";
-import cesr from "../parser/cesr-encoding.js";
-import { MatterCode } from "../parser/codes.js";
-import { decodeBase64, encodeBase64 } from "../parser/base64.js";
-import { decrypt, encrypt } from "./encrypt.js";
-import { blake3 } from "@noble/hashes/blake3";
-export class WebKeyStore {
-    constructor(options) {
-        this.options = options;
-    }
-    async load(publicKey) {
-        const value = localStorage.getItem(publicKey);
-        if (!value) {
-            throw new Error("No such key");
-        }
-        const [key0, key1] = value.split("\n");
-        return [
-            await decrypt(this.options.passphrase, decodeBase64(key0)),
-            await decrypt(this.options.passphrase, decodeBase64(key1)),
-        ];
-    }
-    async incept() {
-        const key0 = ed25519.utils.randomPrivateKey();
-        const key1 = ed25519.utils.randomPrivateKey();
-        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
-        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
-        localStorage.setItem(current, [
-            encodeBase64(await encrypt(this.options.passphrase, key0)),
-            encodeBase64(await encrypt(this.options.passphrase, key1)),
-        ].join("\n"));
-        return { current, next };
-    }
-    async rotate(currentKey) {
-        const [, key0] = await this.load(currentKey);
-        const key1 = ed25519.utils.randomPrivateKey();
-        const current = cesr.encode(MatterCode.Ed25519, ed25519.getPublicKey(key0));
-        const next = cesr.encode(MatterCode.Blake3_256, blake3.create({ dkLen: 32 }).update(current).digest());
-        localStorage.setItem(current, [
-            encodeBase64(await encrypt(this.options.passphrase, key0)),
-            encodeBase64(await encrypt(this.options.passphrase, key1)),
-        ].join("\n"));
-        return { current, next };
-    }
-    async sign(publicKey, message) {
-        const [key] = await this.load(publicKey);
-        return cesr.sign(message, key, "ed25519");
-    }
-}

package/dist/main-common.d.ts

@@ -1,7 +0,0 @@
-import cesr from "./parser/cesr-encoding.ts";
-import { incept } from "./events/incept.ts";
-export * from "./keystore/keystore.ts";
-export * from "./parser/codes.ts";
-export * from "./parser/base64.ts";
-export * from "./parser/parser.ts";
-export { incept, cesr };

package/dist/main-common.js

@@ -1,7 +0,0 @@
-import cesr from "./parser/cesr-encoding.js";
-import { incept } from "./events/incept.js";
-export * from "./keystore/keystore.js";
-export * from "./parser/codes.js";
-export * from "./parser/base64.js";
-export * from "./parser/parser.js";
-export { incept, cesr };

package/dist/main-web.d.ts

@@ -1,2 +0,0 @@
-export * from "./keystore/keystore-web.ts";
-export * from "./main-common.ts";

package/dist/main-web.js

@@ -1,2 +0,0 @@
-export * from "./keystore/keystore-web.js";
-export * from "./main-common.js";

package/dist/parser/base64.d.ts

@@ -1,6 +0,0 @@
-export declare function encodeBase64(uint8: Uint8Array): string;
-export declare function decodeBase64(b64: string): Uint8Array;
-export declare function decodeBase64Int(value: string): number;
-export declare function encodeBase64Int(value: number, length?: number): string;
-export declare function encodeBase64Url(buffer: Uint8Array): string;
-export declare function decodeBase64Url(input: string): Uint8Array;

package/dist/parser/base64.js

@@ -1,74 +0,0 @@
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-const B64_URL_MAP = ALPHABET.split("");
-const B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-export function encodeBase64(uint8) {
-    // CREDIT: https://github.com/denoland/std/blob/main/encoding/base64.ts
-    // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
-    let result = "";
-    let i;
-    const l = uint8.length;
-    for (i = 2; i < l; i += 3) {
-        result += B64_ALPHABET[uint8[i - 2] >> 2];
-        result += B64_ALPHABET[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += B64_ALPHABET[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
-        result += B64_ALPHABET[uint8[i] & 0x3f];
-    }
-    if (i === l + 1) {
-        // 1 octet yet to write
-        result += B64_ALPHABET[uint8[i - 2] >> 2];
-        result += B64_ALPHABET[(uint8[i - 2] & 0x03) << 4];
-        result += "==";
-    }
-    if (i === l) {
-        // 2 octets yet to write
-        result += B64_ALPHABET[uint8[i - 2] >> 2];
-        result += B64_ALPHABET[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
-        result += B64_ALPHABET[(uint8[i - 1] & 0x0f) << 2];
-        result += "=";
-    }
-    return result;
-}
-export function decodeBase64(b64) {
-    // CREDIT: https://github.com/denoland/std/blob/main/encoding/base64.ts
-    const binString = atob(b64);
-    const size = binString.length;
-    const bytes = new Uint8Array(size);
-    for (let i = 0; i < size; i++) {
-        bytes[i] = binString.charCodeAt(i);
-    }
-    return bytes;
-}
-export function decodeBase64Int(value) {
-    return value
-        .split("")
-        .reverse()
-        .reduce((result, character, index) => {
-        const value = ALPHABET.indexOf(character);
-        const factor = 64 ** index;
-        return result + value * factor;
-    }, 0);
-}
-export function encodeBase64Int(value, length = 1) {
-    let current = value;
-    let result = "";
-    while (length != 0) {
-        result = B64_URL_MAP[current % 64] + result;
-        current = Math.floor(current / 64);
-        if (current == 0) {
-            break;
-        }
-    }
-    return result.padStart(length, "A");
-}
-export function encodeBase64Url(buffer) {
-    return encodeBase64(buffer).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 decodeBase64(base64String);
-}

package/dist/parser/cesr-encoding.d.ts

@@ -1,34 +0,0 @@
-/**
- * Represents the Raw domain
- */
-export interface Raw {
-    code: string;
-    buffer: Uint8Array;
-}
-export declare function decode(text: string): Raw;
-export declare function encodeDate(date: Date): string;
-export declare function encode(code: string, raw: Uint8Array): string;
-/**
- * Converts a cryptographic primitive to indexed material
- */
-export declare function index(text: string, index: number): string;
-export interface Indexed {
-    value: string;
-    index: number;
-}
-/**
- * Converts indexed material to primitive and index
- */
-export declare function deindex(text: string): Indexed;
-export declare function sign(message: Uint8Array, privateKey: Uint8Array, curve: "ed25519"): string;
-export declare function verify(message: Uint8Array, publicKey: string, signature: string): boolean;
-declare const cesr: {
-    encode: typeof encode;
-    decode: typeof decode;
-    sign: typeof sign;
-    verify: typeof verify;
-    index: typeof index;
-    deindex: typeof deindex;
-    encodeDate: typeof encodeDate;
-};
-export default cesr;

package/dist/parser/cesr-encoding.js

@@ -1,158 +0,0 @@
-import { ed25519 } from "@noble/curves/ed25519";
-import { decodeBase64Int, decodeBase64Url, encodeBase64Int, encodeBase64Url } from "./base64.js";
-import { IndexerCode, IndexerCodeTable, MatterCode, MatterCodeTable } from "./codes.js";
-function padNumber(num, length) {
-    return num.toString().padStart(length, "0");
-}
-function findPrimitiveCode(text) {
-    let i = 0;
-    let code = "";
-    let size = null;
-    while (!size && i <= 4) {
-        code = text.slice(0, i);
-        size = MatterCodeTable[text.slice(0, i)];
-        ++i;
-    }
-    if (!size) {
-        throw new Error(`Unable to find code table for ${text}`);
-    }
-    return [code, size];
-}
-function findIndexCode(text) {
-    let i = 0;
-    let code = "";
-    let size = null;
-    while (!size && i <= 4) {
-        code = text.slice(0, i);
-        size = IndexerCodeTable[text.slice(0, i)];
-        ++i;
-    }
-    if (!size) {
-        throw new Error(`Unable to find code table for ${text}`);
-    }
-    return [code, size];
-}
-export function decode(text) {
-    const [code, size] = findPrimitiveCode(text);
-    if (!size) {
-        throw new Error(`Unable to find code table for ${text}`);
-    }
-    const padSize = (size.hs + size.ss) % 4;
-    const padding = "A".repeat(padSize);
-    const paw = decodeBase64Url(padding + text.substring(size.hs + size.ss));
-    const buffer = paw.slice(padSize + (size.ls ?? 0));
-    return { code, buffer };
-}
-export function encodeDate(date) {
-    if (date.toString() === "Invalid Date") {
-        throw new Error("Invalid date");
-    }
-    const YYYY = date.getFullYear();
-    const MM = padNumber(date.getUTCMonth() + 1, 2);
-    const dd = padNumber(date.getUTCDate(), 2);
-    const hh = padNumber(date.getUTCHours(), 2);
-    const mm = padNumber(date.getUTCMinutes(), 2);
-    const ss = padNumber(date.getUTCSeconds(), 2);
-    const ms = padNumber(date.getMilliseconds(), 3);
-    const format = `${YYYY}-${MM}-${dd}T${hh}c${mm}c${ss}d${ms}000p00c00`;
-    return `${MatterCode.DateTime}${format}`;
-}
-export function encode(code, raw) {
-    const both = code;
-    const rs = raw.byteLength;
-    const size = MatterCodeTable[code];
-    if (!size) {
-        throw new Error(`Unable to find code table for ${code}`);
-    }
-    const { hs, ss, xs, fs } = size;
-    const ls = size.ls ?? 0;
-    const cs = hs + ss;
-    let full;
-    if (!fs) {
-        if ((ls + rs) % 3 !== 0 || cs % 4 !== 0) {
-            throw new Error(`Invalid full code=${both} with variable raw size=${rs} given cs=${cs}, hs=${hs}, ss=${ss}, fs=${fs}, and ls=${ls}.`);
-        }
-        const paddedRaw = new Uint8Array(ls + rs);
-        paddedRaw.set(raw, ls);
-        full = both + encodeBase64Url(paddedRaw);
-    }
-    else {
-        const ps = (3 - ((rs + ls) % 3)) % 3;
-        if (ps !== cs % 4) {
-            throw new Error(`Invalid full code=${both} with fixed raw size=${rs} given cs=${cs}, hs=${hs}, ss=${ss}, fs=${fs}, and ls=${ls}.`);
-        }
-        const paddedRaw = new Uint8Array(ps + ls + rs);
-        paddedRaw.set(raw, ps + ls);
-        full = both + encodeBase64Url(paddedRaw).slice(ps);
-    }
-    if (full.length % 4 !== 0 || (fs && full.length !== fs)) {
-        throw new Error(`Invalid full size given code=${both} with raw size=${rs}, cs=${cs}, hs=${hs}, ss=${ss}, xs=${xs}, fs=${fs}, and ls=${ls}.`);
-    }
-    return full;
-}
-function resolveIndexCode(primitiveCode) {
-    switch (primitiveCode) {
-        case MatterCode.Ed25519_Sig:
-            return [IndexerCode.Ed25519_Sig, IndexerCodeTable[IndexerCode.Ed25519_Sig]];
-        case MatterCode.Ed448_Sig:
-            return [IndexerCode.Ed448_Sig, IndexerCodeTable[IndexerCode.Ed448_Sig]];
-    }
-    throw new Error(`Unable to find indexed code for '${primitiveCode}'`);
-}
-function resolvePrimitiveCode(indexCode) {
-    switch (indexCode) {
-        case IndexerCode.Ed25519_Sig:
-            return [MatterCode.Ed25519_Sig, MatterCodeTable[IndexerCode.Ed25519_Sig]];
-        case IndexerCode.Ed448_Sig:
-            return [MatterCode.Ed448_Sig, MatterCodeTable[IndexerCode.Ed448_Sig]];
-    }
-    throw new Error(`Unable to find primitive code for '${indexCode}'`);
-}
-/**
- * Converts a cryptographic primitive to indexed material
- */
-export function index(text, index) {
-    const [code, size] = findPrimitiveCode(text);
-    const [indexCode, indexCodeSize] = resolveIndexCode(code);
-    return indexCode + encodeBase64Int(index, indexCodeSize.ss) + text.slice(size.hs + size.ss);
-}
-/**
- * Converts indexed material to primitive and index
- */
-export function deindex(text) {
-    const [indexCode, indexCodeSize] = findIndexCode(text);
-    const [primitiveCode] = resolvePrimitiveCode(indexCode);
-    const index = decodeBase64Int(text.slice(indexCodeSize.hs, indexCodeSize.ss));
-    const value = primitiveCode + text.slice(indexCodeSize.hs + indexCodeSize.ss);
-    return {
-        index,
-        value,
-    };
-}
-export function sign(message, privateKey, curve) {
-    switch (curve) {
-        case "ed25519":
-            return cesr.encode(MatterCode.Ed25519_Sig, ed25519.sign(message, privateKey));
-        default:
-            throw new Error(`Unsupported curve ${curve}`);
-    }
-}
-export function verify(message, publicKey, signature) {
-    const decodedPublicKey = cesr.decode(publicKey);
-    const decodedSignature = cesr.decode(signature);
-    switch (decodedSignature.code) {
-        case MatterCode.Ed25519_Sig:
-            return ed25519.verify(decodedSignature.buffer, message, decodedPublicKey.buffer);
-    }
-    throw new Error(`Unsupported signature code ${decodedSignature.code}`);
-}
-const cesr = {
-    encode,
-    decode,
-    sign,
-    verify,
-    index,
-    deindex,
-    encodeDate,
-};
-export default cesr;