@peerbit/crypto 1.0.1

package/lib/esm/signature.js

@@ -0,0 +1,283 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { deserialize, variant, field, option, serialize, } from "@dao-xyz/borsh";
+import { equals } from "@peerbit/uint8arrays";
+import { verifySignatureEd25519 } from "./ed25519-sign.js";
+import { Ed25519PublicKey } from "./ed25519.js";
+import { PublicSignKey } from "./key.js";
+import { PreHash } from "./prehash.js";
+import { Secp256k1PublicKey, verifySignatureSecp256k1 } from "./sepc256k1.js";
+export let SignatureWithKey = class SignatureWithKey {
+    signature;
+    publicKey;
+    prehash = PreHash.NONE; // 0 no prehash, 1 sha256, 2 blake3?
+    constructor(props) {
+        if (props) {
+            this.signature = props.signature;
+            this.publicKey = props.publicKey;
+            this.prehash = props.prehash;
+        }
+    }
+    equals(other) {
+        if (!equals(this.signature, other.signature)) {
+            return false;
+        }
+        return (Buffer.compare(serialize(this.publicKey), serialize(other.publicKey)) ===
+            0 && this.prehash == other.prehash);
+    }
+};
+__decorate([
+    field({ type: Uint8Array }),
+    __metadata("design:type", Uint8Array)
+], SignatureWithKey.prototype, "signature", void 0);
+__decorate([
+    field({ type: PublicSignKey }),
+    __metadata("design:type", PublicSignKey)
+], SignatureWithKey.prototype, "publicKey", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], SignatureWithKey.prototype, "prehash", void 0);
+SignatureWithKey = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], SignatureWithKey);
+export let MaybeSigned = class MaybeSigned {
+    data;
+    signature;
+    constructor(props) {
+        if (props) {
+            this.data = props.data;
+            this.signature = props.signature;
+            this._value = props.value;
+        }
+    }
+    _value;
+    getValue(constructor) {
+        return deserialize(this.data, constructor);
+    }
+    async verify() {
+        if (!this.signature) {
+            return true;
+        }
+        return verify(this.signature, this.data);
+    }
+    equals(other) {
+        if (!equals(this.data, other.data)) {
+            return false;
+        }
+        if (!this.signature !== !other.signature) {
+            return false;
+        }
+        if (this.signature && other.signature) {
+            return this.signature.equals(other.signature);
+        }
+        return true;
+    }
+    /**
+     * In place
+     * @param signer
+     */
+    async sign(signer) {
+        const signatureResult = await signer(this.data);
+        this.signature = signatureResult;
+        return this;
+    }
+};
+__decorate([
+    field({ type: Uint8Array }),
+    __metadata("design:type", Uint8Array)
+], MaybeSigned.prototype, "data", void 0);
+__decorate([
+    field({ type: option(SignatureWithKey) }),
+    __metadata("design:type", SignatureWithKey)
+], MaybeSigned.prototype, "signature", void 0);
+MaybeSigned = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], MaybeSigned);
+export const verify = async (signature, data) => {
+    if (signature.publicKey instanceof Ed25519PublicKey) {
+        return verifySignatureEd25519(signature, data);
+    }
+    else if (signature.publicKey instanceof Secp256k1PublicKey) {
+        return verifySignatureSecp256k1(signature, data);
+    }
+    return false;
+};
+/*
+
+@variant(0)
+export class SignatureWithKey {
+    @field({ type: Uint8Array })
+    signature: Uint8Array;
+
+    @field({ type: PublicSignKey })
+    publicKey: PublicSignKey;
+
+    constructor(props?: { signature: Uint8Array; publicKey: PublicSignKey }) {
+        if (props) {
+            this.signature = props.signature;
+            this.publicKey = props.publicKey;
+        }
+    }
+
+    equals(other: SignatureWithKey): boolean {
+        if (!equals(this.signature, other.signature)) {
+            return false;
+        }
+        return (
+            Buffer.compare(
+                serialize(this.publicKey),
+                serialize(other.publicKey)
+            ) === 0
+        );
+    }
+}
+
+@variant(0)
+export abstract class MaybeSigned<T> {
+
+    @field({ type: Uint8Array })
+    data: Uint8Array;
+
+    constructor(props: {
+        data: Uint8Array;
+        value?: T;
+    }) {
+        this.data = props.data;
+        this._value = props.value;
+    }
+
+    _value?: T;
+
+    getValue(constructor: AbstractType<T>): T {
+        return deserialize(this.data, constructor);
+    }
+
+    abstract verify(): Promise<boolean>
+
+    equals(other: MaybeSigned<T>): boolean {
+        if (!equals(this.data, other.data)) {
+            return false;
+        }
+        return true;
+    }
+
+}
+
+@variant(0)
+export class Signed<T> extends MaybeSigned<T> {
+
+    @field({ type: option(SignatureWithKey) })
+    signature: SignatureWithKey;
+
+    constructor(props: {
+        data: Uint8Array;
+        value?: T;
+        signature: SignatureWithKey;
+    }) {
+        super(props)
+        this.signature = props.signature;
+
+    }
+
+    async verify(): Promise<boolean> {
+        return verify(
+            this.signature.signature,
+            this.signature.publicKey,
+            this.data
+        );
+    }
+
+    equals(other: MaybeSigned<T>): boolean {
+        if (other instanceof Signed<T>) {
+            if (!this.signature !== !other.signature) {
+                return false;
+            }
+            if (this.signature && other.signature) {
+                return this.signature.equals(other.signature);
+            }
+            return super.equals(other)
+        }
+        else {
+            return false;
+        }
+    }
+
+
+    async sign(signer: SignWithKey): Promise<MaybeSigned<T>> {
+        const signatureResult = await signer(this.data);
+        this.signature = new SignatureWithKey({
+            publicKey: signatureResult.publicKey,
+            signature: signatureResult.signature,
+        });
+        return this;
+    }
+}
+
+
+@variant(0)
+export class Unsigned<T> extends MaybeSigned<T> {
+
+
+    constructor(props: {
+        data: Uint8Array;
+        value?: T;
+    }) {
+        super(props)
+    }
+
+    equals(other: MaybeSigned<T>): boolean {
+        if (other instanceof Unsigned) {
+            return super.equals(other)
+        }
+        else {
+            return false;
+        }
+    }
+
+   
+    async sign(signer: SignWithKey): Promise<Signed<T>> {
+        const signatureResult = await signer(this.data);
+        return new Signed({
+            data: this.data,
+            signature: new SignatureWithKey({
+                publicKey: signatureResult.publicKey,
+                signature: signatureResult.signature,
+            }),
+            value: this._value
+        });
+    }
+
+    async verify(): Promise<boolean> {
+        return true;
+    }
+}
+
+
+export const verify = (
+    signature: Uint8Array,
+    publicKey: PublicSignKey,
+    data: Uint8Array
+) => {
+    if (!signature) {
+        return true;
+    }
+    if (publicKey instanceof Ed25519PublicKey) {
+        return verifySignatureEd25519(signature, publicKey, data);
+    } else if (publicKey instanceof Secp256k1PublicKey) {
+        return verifySignatureSecp256k1(signature, publicKey, data);
+    }
+    return false;
+};
+
+*/
+//# sourceMappingURL=signature.js.map

package/lib/esm/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.js","sourceRoot":"","sources":["../../src/signature.ts"],"names":[],"mappings":"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"}

package/lib/esm/signer.d.ts

@@ -0,0 +1,10 @@
+import { PublicSignKey } from "./key.js";
+import { PreHash } from "./prehash.js";
+import { SignatureWithKey } from "./signature.js";
+export interface Signer {
+    sign: (bytes: Uint8Array, prehash?: PreHash) => Promise<SignatureWithKey> | SignatureWithKey;
+}
+export type SignWithKey = (bytes: Uint8Array) => Promise<SignatureWithKey> | SignatureWithKey;
+export type Identity<T extends PublicSignKey = PublicSignKey> = Signer & {
+    publicKey: T;
+};

package/lib/esm/signer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=signer.js.map

package/lib/esm/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","sourceRoot":"","sources":["../../src/signer.ts"],"names":[],"mappings":""}

package/lib/esm/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const fromHexString: (hexString: string) => Uint8Array;
+export declare const toHexString: (bytes: Uint8Array) => string;
+export declare const toBase64: (arr: Uint8Array) => string;
+export declare const fromBase64: (base64: string) => Uint8Array;

package/lib/esm/utils.js

@@ -0,0 +1,10 @@
+import sodium from "libsodium-wrappers";
+export const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+export const toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+export const toBase64 = (arr) => {
+    return sodium.to_base64(arr, sodium.base64_variants.ORIGINAL);
+};
+export const fromBase64 = (base64) => {
+    return sodium.from_base64(base64, sodium.base64_variants.ORIGINAL);
+};
+//# sourceMappingURL=utils.js.map

package/lib/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAE,EAAE,CAClD,UAAU,CAAC,IAAI,CACd,SAAS,CAAC,KAAK,CAAC,SAAS,CAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAC7D,CAAC;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAiB,EAAE,EAAE,CAChD,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;AAE3E,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAe,EAAE,EAAE;IAC3C,OAAO,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;AAC/D,CAAC,CAAC;AACF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAc,EAAE,EAAE;IAC5C,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;AACpE,CAAC,CAAC"}

package/lib/esm/x25519.d.ts

@@ -0,0 +1,38 @@
+export * from "./errors.js";
+import { Keypair, PrivateEncryptionKey, PublicKeyEncryptionKey } from "./key.js";
+import { Ed25519Keypair, Ed25519PublicKey } from "./ed25519.js";
+import { PeerId } from "@libp2p/interface-peer-id";
+export declare class X25519PublicKey extends PublicKeyEncryptionKey {
+    publicKey: Uint8Array;
+    constructor(properties: {
+        publicKey: Uint8Array;
+    });
+    equals(other: PublicKeyEncryptionKey): boolean;
+    toString(): string;
+    static from(ed25119PublicKey: Ed25519PublicKey): Promise<X25519PublicKey>;
+    static fromPeerId(peerId: PeerId): Promise<X25519PublicKey>;
+    static create(): Promise<X25519PublicKey>;
+}
+export declare class X25519SecretKey extends PrivateEncryptionKey {
+    secretKey: Uint8Array;
+    constructor(properties: {
+        secretKey: Uint8Array;
+    });
+    equals(other: PublicKeyEncryptionKey): boolean;
+    toString(): string;
+    publicKey(): Promise<X25519PublicKey>;
+    static from(ed25119Keypair: Ed25519Keypair): Promise<X25519SecretKey>;
+    static create(): Promise<X25519SecretKey>;
+}
+export declare class X25519Keypair extends Keypair {
+    publicKey: X25519PublicKey;
+    secretKey: X25519SecretKey;
+    constructor(properties: {
+        publicKey: X25519PublicKey;
+        secretKey: X25519SecretKey;
+    });
+    static create(): Promise<X25519Keypair>;
+    static from(ed25119Keypair: Ed25519Keypair): Promise<X25519Keypair>;
+    static fromPeerId(peerId: PeerId): Promise<X25519Keypair>;
+    equals(other: Keypair): boolean;
+}

package/lib/esm/x25519.js

@@ -0,0 +1,158 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var X25519PublicKey_1, X25519SecretKey_1, X25519Keypair_1;
+export * from "./errors.js";
+import { field, fixedArray, variant } from "@dao-xyz/borsh";
+import { compare } from "@peerbit/uint8arrays";
+import sodium from "libsodium-wrappers";
+import { Keypair, PrivateEncryptionKey, PublicKeyEncryptionKey, } from "./key.js";
+import { Ed25519Keypair, Ed25519PublicKey, } from "./ed25519.js";
+import { toHexString } from "./utils.js";
+export let X25519PublicKey = X25519PublicKey_1 = class X25519PublicKey extends PublicKeyEncryptionKey {
+    publicKey;
+    constructor(properties) {
+        super();
+        if (properties.publicKey.length !== 32) {
+            throw new Error("Expecting key to have length 32");
+        }
+        this.publicKey = properties.publicKey;
+    }
+    equals(other) {
+        if (other instanceof X25519PublicKey_1) {
+            return compare(this.publicKey, other.publicKey) === 0;
+        }
+        return false;
+    }
+    toString() {
+        return "x25519p/" + toHexString(this.publicKey);
+    }
+    static async from(ed25119PublicKey) {
+        await sodium.ready;
+        return new X25519PublicKey_1({
+            publicKey: sodium.crypto_sign_ed25519_pk_to_curve25519(ed25119PublicKey.publicKey),
+        });
+    }
+    static async fromPeerId(peerId) {
+        await sodium.ready;
+        const ed = await Ed25519PublicKey.fromPeerId(peerId);
+        return X25519PublicKey_1.from(ed);
+    }
+    static async create() {
+        await sodium.ready;
+        return new X25519PublicKey_1({
+            publicKey: sodium.crypto_box_keypair().publicKey,
+        });
+    }
+};
+__decorate([
+    field({ type: fixedArray("u8", 32) }),
+    __metadata("design:type", Uint8Array)
+], X25519PublicKey.prototype, "publicKey", void 0);
+X25519PublicKey = X25519PublicKey_1 = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], X25519PublicKey);
+export let X25519SecretKey = X25519SecretKey_1 = class X25519SecretKey extends PrivateEncryptionKey {
+    secretKey;
+    constructor(properties) {
+        super();
+        if (properties.secretKey.length !== 32) {
+            throw new Error("Expecting key to have length 32");
+        }
+        this.secretKey = properties.secretKey;
+    }
+    equals(other) {
+        if (other instanceof X25519SecretKey_1) {
+            return (compare(this.secretKey, other.secretKey) === 0);
+        }
+        return false;
+    }
+    toString() {
+        return "x25519s" + toHexString(this.secretKey);
+    }
+    async publicKey() {
+        return new X25519PublicKey({
+            publicKey: sodium.crypto_scalarmult_base(this.secretKey),
+        });
+    }
+    static async from(ed25119Keypair) {
+        await sodium.ready;
+        return new X25519SecretKey_1({
+            secretKey: sodium.crypto_sign_ed25519_sk_to_curve25519(ed25119Keypair.privateKeyPublicKey),
+        });
+    }
+    static async create() {
+        await sodium.ready;
+        return new X25519SecretKey_1({
+            secretKey: sodium.crypto_box_keypair().privateKey,
+        });
+    }
+};
+__decorate([
+    field({ type: fixedArray("u8", 32) }),
+    __metadata("design:type", Uint8Array)
+], X25519SecretKey.prototype, "secretKey", void 0);
+X25519SecretKey = X25519SecretKey_1 = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], X25519SecretKey);
+export let X25519Keypair = X25519Keypair_1 = class X25519Keypair extends Keypair {
+    publicKey;
+    secretKey;
+    constructor(properties) {
+        super();
+        this.publicKey = properties.publicKey;
+        this.secretKey = properties.secretKey;
+    }
+    static async create() {
+        await sodium.ready;
+        const generated = sodium.crypto_box_keypair();
+        const kp = new X25519Keypair_1({
+            publicKey: new X25519PublicKey({
+                publicKey: generated.publicKey,
+            }),
+            secretKey: new X25519SecretKey({
+                secretKey: generated.privateKey,
+            }),
+        });
+        return kp;
+    }
+    static async from(ed25119Keypair) {
+        const kp = new X25519Keypair_1({
+            publicKey: await X25519PublicKey.from(ed25119Keypair.publicKey),
+            secretKey: await X25519SecretKey.from(ed25119Keypair),
+        });
+        return kp;
+    }
+    static fromPeerId(peerId) {
+        const ed = Ed25519Keypair.fromPeerId(peerId);
+        return X25519Keypair_1.from(ed);
+    }
+    equals(other) {
+        if (other instanceof X25519Keypair_1) {
+            return (this.publicKey.equals(other.publicKey) &&
+                this.secretKey.equals(other.secretKey));
+        }
+        return false;
+    }
+};
+__decorate([
+    field({ type: X25519PublicKey }),
+    __metadata("design:type", X25519PublicKey)
+], X25519Keypair.prototype, "publicKey", void 0);
+__decorate([
+    field({ type: X25519SecretKey }),
+    __metadata("design:type", X25519SecretKey)
+], X25519Keypair.prototype, "secretKey", void 0);
+X25519Keypair = X25519Keypair_1 = __decorate([
+    variant(1),
+    __metadata("design:paramtypes", [Object])
+], X25519Keypair);
+//# sourceMappingURL=x25519.js.map

package/lib/esm/x25519.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"x25519.js","sourceRoot":"","sources":["../../src/x25519.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@peerbit/crypto",
+	"version": "1.0.1",
+	"description": "Crypto fn",
+	"type": "module",
+	"sideEffects": false,
+	"module": "lib/esm/index.js",
+	"types": "lib/esm/index.d.ts",
+	"exports": {
+		"import": "./lib/esm/index.js"
+	},
+	"files": [
+		"lib",
+		"src",
+		"!src/**/__tests__",
+		"!lib/**/__tests__",
+		"!src/**/__benchmark__",
+		"!lib/**/__benchmark__",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"browser": {
+		"./lib/esm/hash.js": "./lib/esm/hash-browser.js",
+		"./hash.js": "./lib/esm/hash-browser.js",
+		"./lib/esm/random.js": "./lib/esm/random-browser.js",
+		"./random.js": "./lib/esm/random-browser.js",
+		"./lib/esm/ed25519-sign.js": "./lib/esm/ed25519-sign-browser.js",
+		"./ed25519-sign.js": "./lib/esm/ed25519-sign-browser.js"
+	},
+	"scripts": {
+		"clean": "shx rm -rf lib/*",
+		"build": "yarn clean && tsc -p tsconfig.json",
+		"test": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.ts --runInBand --forceExit",
+		"test:unit": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.unit.ts --runInBand --forceExit",
+		"test:integration": "node ../node_modules/.bin/jest test -c  ../../../jest.config.integration.ts --runInBand --forceExit"
+	},
+	"author": "dao.xyz",
+	"license": "MIT",
+	"devDependencies": {
+		"@types/libsodium-wrappers": "^0.7.10",
+		"uint8arrays": "^4.0.4"
+	},
+	"dependencies": {
+		"@dao-xyz/borsh": "^5.1.5",
+		"@ethersproject/wallet": "^5.7.0",
+		"@libp2p/crypto": "^1.0.17",
+		"@libp2p/peer-id": "^2.0.3",
+		"@peerbit/cache": "^1.0.0",
+		"@peerbit/uint8arrays": "2.0.0",
+		"libsodium-wrappers": "^0.7.11"
+	},
+	"gitHead": "069ce2f62a76c342875a1cc695c6f210beff13fd"
+}

package/src/bytes.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
+ * @returns {Uint8Array}
+ */
+export const coerce = (o) => {
+	if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") return o;
+	if (o instanceof ArrayBuffer) return new Uint8Array(o);
+	if (ArrayBuffer.isView(o)) {
+		return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+	}
+	throw new Error("Unknown type, must be binary type");
+};

package/src/ed25519-sign-browser.ts

@@ -0,0 +1,43 @@
+import { Ed25519Keypair, Ed25519PublicKey } from "./ed25519.js";
+import sodium from "libsodium-wrappers";
+import { PreHash, prehashFn } from "./prehash.js";
+import { SignatureWithKey } from "./signature.js";
+
+export const sign = async (
+	data: Uint8Array,
+	keypair: Ed25519Keypair,
+	prehash: PreHash
+) => {
+	const hashedData = await prehashFn(data, prehash);
+	/* const init = sodium.crypto_sign_init()
+	sodium.crypto_sign_update(init, hashedData)
+	const signature = sodium.crypto_sign_final_create(init, keypair.privateKey.privateKey, 'uint8array') */
+	return new SignatureWithKey({
+		prehash,
+		publicKey: keypair.publicKey,
+		signature: sodium.crypto_sign_detached(
+			hashedData,
+			keypair.privateKeyPublicKey
+		),
+	});
+};
+
+export const verifySignatureEd25519 = async (
+	signature: SignatureWithKey,
+	data: Uint8Array
+) => {
+	let res = false;
+	try {
+		const hashedData = await prehashFn(data, signature.prehash);
+
+		const verified = sodium.crypto_sign_verify_detached(
+			signature.signature,
+			hashedData,
+			(signature.publicKey as Ed25519PublicKey).publicKey
+		);
+		res = verified;
+	} catch (error) {
+		return false;
+	}
+	return res;
+};