@reallyme/crypto 0.1.0

package/README.md

@@ -0,0 +1,140 @@
+<!--
+SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ReallyMeCrypto TypeScript
+
+`@reallyme/crypto` is the TypeScript package for the ReallyMe Crypto workspace.
+It gives Node and browser applications the same algorithm identifiers, byte
+formats, provider policy, and fail-closed verification behavior used by the
+Rust, Swift, and Kotlin packages.
+
+The npm API is synchronous. WebCrypto is intentionally not part of this facade:
+adding an async-only provider would change every call site. Primitives that
+should stay shared with Rust are provided by the generated WASM module.
+
+## Install
+
+```sh
+npm install @reallyme/crypto
+```
+
+## Quick Start
+
+```ts
+import { ReallyMeCrypto } from "@reallyme/crypto";
+
+const digest = ReallyMeCrypto.hash(
+  "SHA2-256",
+  new TextEncoder().encode("abc"),
+);
+
+const tag = ReallyMeCrypto.authenticate(
+  "HMAC-SHA-256",
+  key,
+  new TextEncoder().encode("message"),
+);
+```
+
+Signature verification throws `ReallyMeCryptoError` on invalid signatures. It
+does not return a boolean that can be accidentally ignored.
+
+## Provider Model
+
+Provider selection is explicit:
+
+- `@noble/curves` and `@noble/hashes`, pinned to the versions exercised by the
+  TypeScript conformance lane, for JavaScript-native classical primitives.
+- The ReallyMe Rust WASM lane for primitives that should stay shared with Rust,
+  including ML-KEM, ML-DSA, SLH-DSA, X-Wing, Argon2id, AES-GCM-SIV, XChaCha,
+  AES-KW, HPKE, RSA verify, and codecs.
+
+The public API has two layers:
+
+- algorithm-specific objects, such as `ReallyMeEd25519`, `ReallyMeX25519`,
+  `ReallyMeP256Ecdh`, `ReallyMeSecp256k1`, and `ReallyMeCodecs`;
+- `ReallyMeCrypto`, a typed facade keyed by repository-wide algorithm string
+  unions.
+
+Reserved identifiers, future contract entries, and unsupported overload shapes
+throw `ReallyMeCryptoError` with code `unsupported-algorithm`. The npm package
+does not silently fall back to a different provider. The complete TypeScript
+lane is tracked in [PROVIDER_POLICY.md](../../PROVIDER_POLICY.md).
+
+## Protobuf
+
+The package exports generated protobuf identifiers and boundary adapters from
+`@reallyme/crypto/proto`.
+
+```ts
+import {
+  HashAlgorithm,
+  hashAlgorithmFromProto,
+  hashAlgorithmToProto,
+} from "@reallyme/crypto/proto";
+
+const facadeAlgorithm = hashAlgorithmFromProto(HashAlgorithm.SHA2_256);
+const protoAlgorithm = hashAlgorithmToProto(facadeAlgorithm);
+```
+
+`UNSPECIFIED`, unrecognized values, and private multicodec identifiers throw
+`ReallyMeCryptoError` with code `unsupported-algorithm`.
+
+## WASM Providers
+
+WASM-backed operations require the generated module to be initialized and
+installed before use. If the provider is missing, those operations fail closed
+with `provider-failure`.
+
+```ts
+import { readFileSync } from "node:fs";
+import { installReallyMeWasmProvider } from "@reallyme/crypto";
+import * as wasmProvider from "@reallyme/crypto/wasm/reallyme_crypto_wasm.js";
+
+wasmProvider.initSync({
+  module: readFileSync("reallyme_crypto_wasm_bg.wasm"),
+});
+installReallyMeWasmProvider(wasmProvider);
+```
+
+After installation, the facade routes WASM-backed algorithms through that
+provider:
+
+```ts
+import { ReallyMeCrypto } from "@reallyme/crypto";
+
+const keyPair = ReallyMeCrypto.generateKemKeyPair("X-Wing-768");
+const encapsulation = ReallyMeCrypto.encapsulate("X-Wing-768", keyPair.publicKey);
+const sharedSecret = ReallyMeCrypto.decapsulate(
+  "X-Wing-768",
+  encapsulation.ciphertext,
+  keyPair.secretKey,
+);
+```
+
+Building the WASM artifact requires `wasm-pack` `0.15.0` or newer and
+`wasm-bindgen-cli` `0.2.126` or newer.
+
+```sh
+cargo install wasm-pack --version 0.15.0 --locked
+cargo install wasm-bindgen-cli --version 0.2.126 --locked
+npm --prefix packages/ts test
+```
+
+## Test
+
+```sh
+cd packages/ts
+npm ci
+npm test
+```
+
+## Publish
+
+The npm package name is `@reallyme/crypto`. Release builds publish from
+`packages/ts` with the generated WASM artifact included.
+
+This package is the SDK API. The conformance verifiers under
+`crates/conformance/vectors` remain test harnesses.

package/dist/aead.d.ts

@@ -0,0 +1,9 @@
+import type { ReallyMeAeadAlgorithm } from "./algorithms.js";
+export declare const AEAD_KEY_LENGTH = 32;
+export declare const AEAD_NONCE_LENGTH = 12;
+export declare const XCHACHA20_POLY1305_NONCE_LENGTH = 24;
+export declare const AEAD_TAG_LENGTH = 16;
+export declare const ReallyMeAead: {
+    readonly seal: (algorithm: ReallyMeAeadAlgorithm, key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array) => Uint8Array;
+    readonly open: (algorithm: ReallyMeAeadAlgorithm, key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array) => Uint8Array;
+};

package/dist/aead.js

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { ensureBytes } from "./validateBytes.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+export const AEAD_KEY_LENGTH = 32;
+export const AEAD_NONCE_LENGTH = 12;
+export const XCHACHA20_POLY1305_NONCE_LENGTH = 24;
+export const AEAD_TAG_LENGTH = 16;
+const aeadSuite = (algorithm) => {
+    const provider = requireReallyMeWasmProvider();
+    switch (algorithm) {
+        case "AES-256-GCM":
+            return {
+                nonceLength: AEAD_NONCE_LENGTH,
+                seal: provider.aes256GcmSeal,
+                open: provider.aes256GcmOpen,
+            };
+        case "AES-256-GCM-SIV":
+            return {
+                nonceLength: AEAD_NONCE_LENGTH,
+                seal: provider.aes256GcmSivSeal,
+                open: provider.aes256GcmSivOpen,
+            };
+        case "ChaCha20-Poly1305":
+            return {
+                nonceLength: AEAD_NONCE_LENGTH,
+                seal: provider.chacha20Poly1305Seal,
+                open: provider.chacha20Poly1305Open,
+            };
+        case "XChaCha20-Poly1305":
+            return {
+                nonceLength: XCHACHA20_POLY1305_NONCE_LENGTH,
+                seal: provider.xchacha20Poly1305Seal,
+                open: provider.xchacha20Poly1305Open,
+            };
+    }
+};
+const requireBytesOutput = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+export const ReallyMeAead = {
+    seal(algorithm, key, nonce, aad, plaintext) {
+        const suite = aeadSuite(algorithm);
+        ensureBytes(key, AEAD_KEY_LENGTH);
+        ensureBytes(nonce, suite.nonceLength);
+        return requireBytesOutput(suite.seal(key, nonce, aad, plaintext));
+    },
+    open(algorithm, key, nonce, aad, ciphertextWithTag) {
+        const suite = aeadSuite(algorithm);
+        ensureBytes(key, AEAD_KEY_LENGTH);
+        ensureBytes(nonce, suite.nonceLength);
+        if (ciphertextWithTag.length < AEAD_TAG_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        return requireBytesOutput(suite.open(key, nonce, aad, ciphertextWithTag));
+    },
+};

package/dist/aesKw.d.ts

@@ -0,0 +1,10 @@
+export declare const AES_256_KW_KEK_LENGTH = 32;
+export declare const AES_KW_BLOCK_LENGTH = 8;
+export declare const AES_KW_INTEGRITY_CHECK_LENGTH = 8;
+export declare const AES_KW_MIN_KEY_DATA_LENGTH = 16;
+export declare const AES_KW_MIN_WRAPPED_KEY_LENGTH: number;
+export declare const AES_KW_MAX_KEY_DATA_LENGTH = 4096;
+export declare const ReallyMeAesKw: {
+    readonly wrapKey: (wrappingKey: Uint8Array, keyToWrap: Uint8Array) => Uint8Array;
+    readonly unwrapKey: (wrappingKey: Uint8Array, wrappedKey: Uint8Array) => Uint8Array;
+};

package/dist/aesKw.js

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { ensureBytes } from "./validateBytes.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+export const AES_256_KW_KEK_LENGTH = 32;
+export const AES_KW_BLOCK_LENGTH = 8;
+export const AES_KW_INTEGRITY_CHECK_LENGTH = 8;
+export const AES_KW_MIN_KEY_DATA_LENGTH = 16;
+export const AES_KW_MIN_WRAPPED_KEY_LENGTH = AES_KW_MIN_KEY_DATA_LENGTH + AES_KW_INTEGRITY_CHECK_LENGTH;
+export const AES_KW_MAX_KEY_DATA_LENGTH = 4_096;
+const validateKeyDataLength = (length) => {
+    if (length < AES_KW_MIN_KEY_DATA_LENGTH ||
+        length > AES_KW_MAX_KEY_DATA_LENGTH ||
+        length % AES_KW_BLOCK_LENGTH !== 0) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const validateWrappedKeyLength = (length) => {
+    const maxWrappedLength = AES_KW_MAX_KEY_DATA_LENGTH + AES_KW_INTEGRITY_CHECK_LENGTH;
+    if (length < AES_KW_MIN_WRAPPED_KEY_LENGTH ||
+        length > maxWrappedLength ||
+        length % AES_KW_BLOCK_LENGTH !== 0) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const requireBytesOutput = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+export const ReallyMeAesKw = {
+    wrapKey(wrappingKey, keyToWrap) {
+        ensureBytes(wrappingKey, AES_256_KW_KEK_LENGTH);
+        validateKeyDataLength(keyToWrap.length);
+        return requireBytesOutput(requireReallyMeWasmProvider().aes256KwWrapKey(wrappingKey, keyToWrap));
+    },
+    unwrapKey(wrappingKey, wrappedKey) {
+        ensureBytes(wrappingKey, AES_256_KW_KEK_LENGTH);
+        validateWrappedKeyLength(wrappedKey.length);
+        return requireBytesOutput(requireReallyMeWasmProvider().aes256KwUnwrapKey(wrappingKey, wrappedKey));
+    },
+};

package/dist/algorithms.d.ts

@@ -0,0 +1,18 @@
+export declare const REALLYME_SIGNATURE_ALGORITHMS: readonly ["Ed25519", "ECDSA-P256-SHA256", "ECDSA-P384-SHA384", "ECDSA-P521-SHA512", "ECDSA-secp256k1-SHA256", "BIP340-Schnorr-secp256k1-SHA256", "RSA-PKCS1v15-SHA1", "RSA-PKCS1v15-SHA256", "RSA-PKCS1v15-SHA384", "RSA-PKCS1v15-SHA512", "RSA-PSS-SHA1-MGF1-SHA1", "RSA-PSS-SHA256-MGF1-SHA256", "RSA-PSS-SHA384-MGF1-SHA384", "RSA-PSS-SHA512-MGF1-SHA512", "ML-DSA-44", "ML-DSA-65", "ML-DSA-87", "SLH-DSA-SHA2-128s"];
+export type ReallyMeSignatureAlgorithm = (typeof REALLYME_SIGNATURE_ALGORITHMS)[number];
+export declare const REALLYME_HASH_ALGORITHMS: readonly ["SHA2-256", "SHA2-384", "SHA2-512", "SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512"];
+export type ReallyMeHashAlgorithm = (typeof REALLYME_HASH_ALGORITHMS)[number];
+export declare const REALLYME_AEAD_ALGORITHMS: readonly ["AES-256-GCM", "AES-256-GCM-SIV", "ChaCha20-Poly1305", "XChaCha20-Poly1305"];
+export type ReallyMeAeadAlgorithm = (typeof REALLYME_AEAD_ALGORITHMS)[number];
+export declare const REALLYME_KEM_ALGORITHMS: readonly ["ML-KEM-512", "ML-KEM-768", "ML-KEM-1024", "X-Wing-768", "X-Wing-1024"];
+export type ReallyMeKemAlgorithm = (typeof REALLYME_KEM_ALGORITHMS)[number];
+export declare const REALLYME_KEY_AGREEMENT_ALGORITHMS: readonly ["X25519", "P-256-ECDH"];
+export type ReallyMeKeyAgreementAlgorithm = (typeof REALLYME_KEY_AGREEMENT_ALGORITHMS)[number];
+export declare const REALLYME_MAC_ALGORITHMS: readonly ["HMAC-SHA-256", "HMAC-SHA-512"];
+export type ReallyMeMacAlgorithm = (typeof REALLYME_MAC_ALGORITHMS)[number];
+export declare const REALLYME_KDF_ALGORITHMS: readonly ["HKDF-SHA256", "Argon2id", "PBKDF2-HMAC-SHA-256", "PBKDF2-HMAC-SHA-512"];
+export type ReallyMeKdfAlgorithm = (typeof REALLYME_KDF_ALGORITHMS)[number];
+export declare const REALLYME_KEY_WRAP_ALGORITHMS: readonly ["AES-256-KW"];
+export type ReallyMeKeyWrapAlgorithm = (typeof REALLYME_KEY_WRAP_ALGORITHMS)[number];
+export declare const REALLYME_HPKE_SUITES: readonly ["DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM", "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305"];
+export type ReallyMeHpkeSuite = (typeof REALLYME_HPKE_SUITES)[number];

package/dist/algorithms.js

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+export const REALLYME_SIGNATURE_ALGORITHMS = [
+    "Ed25519",
+    "ECDSA-P256-SHA256",
+    "ECDSA-P384-SHA384",
+    "ECDSA-P521-SHA512",
+    "ECDSA-secp256k1-SHA256",
+    "BIP340-Schnorr-secp256k1-SHA256",
+    "RSA-PKCS1v15-SHA1",
+    "RSA-PKCS1v15-SHA256",
+    "RSA-PKCS1v15-SHA384",
+    "RSA-PKCS1v15-SHA512",
+    "RSA-PSS-SHA1-MGF1-SHA1",
+    "RSA-PSS-SHA256-MGF1-SHA256",
+    "RSA-PSS-SHA384-MGF1-SHA384",
+    "RSA-PSS-SHA512-MGF1-SHA512",
+    "ML-DSA-44",
+    "ML-DSA-65",
+    "ML-DSA-87",
+    "SLH-DSA-SHA2-128s",
+];
+export const REALLYME_HASH_ALGORITHMS = [
+    "SHA2-256",
+    "SHA2-384",
+    "SHA2-512",
+    "SHA3-224",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+];
+export const REALLYME_AEAD_ALGORITHMS = [
+    "AES-256-GCM",
+    "AES-256-GCM-SIV",
+    "ChaCha20-Poly1305",
+    "XChaCha20-Poly1305",
+];
+export const REALLYME_KEM_ALGORITHMS = [
+    "ML-KEM-512",
+    "ML-KEM-768",
+    "ML-KEM-1024",
+    "X-Wing-768",
+    "X-Wing-1024",
+];
+export const REALLYME_KEY_AGREEMENT_ALGORITHMS = [
+    "X25519",
+    "P-256-ECDH",
+];
+export const REALLYME_MAC_ALGORITHMS = [
+    "HMAC-SHA-256",
+    "HMAC-SHA-512",
+];
+export const REALLYME_KDF_ALGORITHMS = [
+    "HKDF-SHA256",
+    "Argon2id",
+    "PBKDF2-HMAC-SHA-256",
+    "PBKDF2-HMAC-SHA-512",
+];
+export const REALLYME_KEY_WRAP_ALGORITHMS = ["AES-256-KW"];
+export const REALLYME_HPKE_SUITES = [
+    "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM",
+    "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305",
+];

package/dist/argon2id.d.ts

@@ -0,0 +1,8 @@
+export declare const ARGON2ID_DERIVED_KEY_LENGTH = 32;
+export declare const ARGON2ID_SALT_MIN_LENGTH = 16;
+export declare const ARGON2ID_SALT_MAX_LENGTH = 32;
+export declare const ARGON2ID_V1 = 1;
+export declare const ARGON2ID_V2 = 2;
+export declare const ReallyMeArgon2id: {
+    readonly deriveKey: (kdfVersion: number, secret: Uint8Array, salt: Uint8Array) => Uint8Array;
+};

package/dist/argon2id.js

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCryptoError } from "./errors.js";
+import { requireReallyMeWasmProvider } from "./wasmProvider.js";
+export const ARGON2ID_DERIVED_KEY_LENGTH = 32;
+export const ARGON2ID_SALT_MIN_LENGTH = 16;
+export const ARGON2ID_SALT_MAX_LENGTH = 32;
+export const ARGON2ID_V1 = 1;
+export const ARGON2ID_V2 = 2;
+const validateVersion = (kdfVersion) => {
+    if (!Number.isInteger(kdfVersion) ||
+        (kdfVersion !== ARGON2ID_V1 && kdfVersion !== ARGON2ID_V2)) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const validateSecret = (secret) => {
+    if (secret.length === 0) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const validateSalt = (salt) => {
+    if (salt.length < ARGON2ID_SALT_MIN_LENGTH || salt.length > ARGON2ID_SALT_MAX_LENGTH) {
+        throw new ReallyMeCryptoError("invalid-input");
+    }
+};
+const requireDerivedKey = (value) => {
+    if (!(value instanceof Uint8Array) || value.length !== ARGON2ID_DERIVED_KEY_LENGTH) {
+        throw new ReallyMeCryptoError("provider-failure");
+    }
+    return value;
+};
+export const ReallyMeArgon2id = {
+    deriveKey(kdfVersion, secret, salt) {
+        validateVersion(kdfVersion);
+        validateSecret(secret);
+        validateSalt(salt);
+        return requireDerivedKey(requireReallyMeWasmProvider().argon2idDeriveKey(kdfVersion, secret, salt));
+    },
+};

package/dist/bip340Schnorr.d.ts

@@ -0,0 +1,26 @@
+export declare const BIP340_SCHNORR_SECRET_KEY_LENGTH = 32;
+export declare const BIP340_SCHNORR_PUBLIC_KEY_LENGTH = 32;
+export declare const BIP340_SCHNORR_MESSAGE_LENGTH = 32;
+export declare const BIP340_SCHNORR_AUX_RAND_LENGTH = 32;
+export declare const BIP340_SCHNORR_SIGNATURE_LENGTH = 64;
+/**
+ * BIP-340 Schnorr over secp256k1 backed by @noble/curves.
+ *
+ * BIP-340 signs a 32-byte message representative and requires 32 bytes of
+ * auxiliary randomness. Keeping `auxRand32` explicit matches the Rust, Swift,
+ * and Kotlin lanes and avoids a hidden provider-specific randomness policy at
+ * the generic facade boundary.
+ */
+export declare const ReallyMeBip340Schnorr: {
+    readonly generateKeyPair: () => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly deriveKeyPair: (secretKey: Uint8Array) => {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    readonly derivePublicKey: (secretKey: Uint8Array) => Uint8Array;
+    readonly sign: (message32: Uint8Array, secretKey: Uint8Array, auxRand32: Uint8Array) => Uint8Array;
+    readonly verify: (signature: Uint8Array, message32: Uint8Array, publicKey: Uint8Array) => void;
+};

package/dist/bip340Schnorr.js

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
+import { ReallyMeCryptoError } from "./errors.js";
+export const BIP340_SCHNORR_SECRET_KEY_LENGTH = 32;
+export const BIP340_SCHNORR_PUBLIC_KEY_LENGTH = 32;
+export const BIP340_SCHNORR_MESSAGE_LENGTH = 32;
+export const BIP340_SCHNORR_AUX_RAND_LENGTH = 32;
+export const BIP340_SCHNORR_SIGNATURE_LENGTH = 64;
+/**
+ * BIP-340 Schnorr over secp256k1 backed by @noble/curves.
+ *
+ * BIP-340 signs a 32-byte message representative and requires 32 bytes of
+ * auxiliary randomness. Keeping `auxRand32` explicit matches the Rust, Swift,
+ * and Kotlin lanes and avoids a hidden provider-specific randomness policy at
+ * the generic facade boundary.
+ */
+export const ReallyMeBip340Schnorr = {
+    generateKeyPair() {
+        const secretKey = secp256k1.utils.randomSecretKey();
+        return {
+            publicKey: schnorr.getPublicKey(secretKey),
+            secretKey,
+        };
+    },
+    deriveKeyPair(secretKey) {
+        return {
+            publicKey: this.derivePublicKey(secretKey),
+            secretKey: secretKey.slice(),
+        };
+    },
+    derivePublicKey(secretKey) {
+        if (secretKey.length !== BIP340_SCHNORR_SECRET_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return schnorr.getPublicKey(secretKey);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+    sign(message32, secretKey, auxRand32) {
+        if (message32.length !== BIP340_SCHNORR_MESSAGE_LENGTH ||
+            secretKey.length !== BIP340_SCHNORR_SECRET_KEY_LENGTH ||
+            auxRand32.length !== BIP340_SCHNORR_AUX_RAND_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            return schnorr.sign(message32, secretKey, auxRand32);
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+    },
+    verify(signature, message32, publicKey) {
+        if (signature.length !== BIP340_SCHNORR_SIGNATURE_LENGTH ||
+            message32.length !== BIP340_SCHNORR_MESSAGE_LENGTH ||
+            publicKey.length !== BIP340_SCHNORR_PUBLIC_KEY_LENGTH) {
+            throw new ReallyMeCryptoError("invalid-input");
+        }
+        try {
+            if (!schnorr.verify(signature, message32, publicKey)) {
+                throw new ReallyMeCryptoError("invalid-signature");
+            }
+        }
+        catch {
+            throw new ReallyMeCryptoError("invalid-signature");
+        }
+    },
+};

package/dist/codecs.d.ts

@@ -0,0 +1,35 @@
+export type ReallyMeMulticodecTag = "encryption" | "hash" | "key" | "multihash" | "multikey";
+export type ReallyMeKeyMaterialKind = "not-key" | "public-key" | "private-key" | "symmetric-key";
+export type ReallyMeMulticodecMetadata = Readonly<{
+    name: string;
+    alg: string;
+    tag: ReallyMeMulticodecTag;
+    keyMaterial: ReallyMeKeyMaterialKind;
+    prefix: Uint8Array;
+    expectedKeyLength?: number;
+}>;
+export type ReallyMeParsedMultikey = Readonly<{
+    codecName: string;
+    algorithmName: string;
+    publicKey: Uint8Array;
+    expectedPublicKeyLength?: number;
+}>;
+export type ReallyMeDagCborCidVerification = Readonly<{
+    valid: boolean;
+    expectedCid: string;
+    actualCid: string;
+}>;
+export declare const ReallyMeCodecs: {
+    readonly base64urlEncode: (bytes: Uint8Array) => string;
+    readonly base64urlDecode: (encoded: string) => Uint8Array;
+    readonly base64urlDecodeBytes: (encoded: Uint8Array) => Uint8Array;
+    readonly multibaseBase64urlEncode: (bytes: Uint8Array) => string;
+    readonly multibaseBase58btcEncode: (bytes: Uint8Array) => string;
+    readonly multibaseDecode: (encoded: string) => Uint8Array;
+    readonly multicodecPrefixForName: (codecName: string) => ReallyMeMulticodecMetadata;
+    readonly multicodecLookupPrefix: (bytes: Uint8Array) => ReallyMeMulticodecMetadata;
+    readonly multikeyEncode: (codecName: string, publicKey: Uint8Array) => string;
+    readonly multikeyParse: (multikey: string) => ReallyMeParsedMultikey;
+    readonly dagCborComputeCid: (bytes: Uint8Array) => string;
+    readonly dagCborVerifyCid: (cid: string, bytes: Uint8Array) => ReallyMeDagCborCidVerification;
+};