@reallyme/crypto 0.1.7 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reallyme/crypto",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "ReallyMe crypto SDK for TypeScript/JavaScript with an explicit, pinned provider set.",
   "license": "Apache-2.0",
   "type": "module",
@@ -25,19 +25,24 @@
   },
   "files": [
     "dist",
+    "LICENSE",
     "README.md"
   ],
   "scripts": {
     "build": "node scripts/clean-dist.mjs && npm run build:wasm && tsc",
     "build:ts": "tsc",
     "build:wasm": "node scripts/build-wasm.mjs",
+    "pack:check": "node scripts/check-pack.mjs",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm test && npm run pack:check",
     "typecheck": "tsc --noEmit",
     "test": "npm run build && node --test \"test/*.test.mjs\""
   },
   "dependencies": {
     "@bufbuild/protobuf": "2.12.1",
     "@noble/curves": "2.2.0",
-    "@noble/hashes": "2.2.0"
+    "@noble/hashes": "2.2.0",
+    "@reallyme/codec": "0.1.21"
   },
   "devDependencies": {
     "typescript": "5.8.3"

package/dist/codecs.d.ts

@@ -1,35 +0,0 @@
-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;
-};

package/dist/codecs.js

@@ -1,216 +0,0 @@
-// 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";
-const validTags = new Set([
-    "encryption",
-    "hash",
-    "key",
-    "multihash",
-    "multikey",
-]);
-const validKeyMaterialKinds = new Set([
-    "not-key",
-    "public-key",
-    "private-key",
-    "symmetric-key",
-]);
-const ensureStringInput = (value) => {
-    if (typeof value !== "string" || value.length === 0) {
-        throw new ReallyMeCryptoError("invalid-input");
-    }
-};
-const ensureBytesInput = (value) => {
-    if (!(value instanceof Uint8Array)) {
-        throw new ReallyMeCryptoError("invalid-input");
-    }
-};
-const requireObjectOutput = (value) => {
-    if (typeof value !== "object" || value === null) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return value;
-};
-const readStringOutput = (value) => {
-    if (typeof value !== "string") {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return value;
-};
-const readBytesOutput = (value) => {
-    if (!(value instanceof Uint8Array)) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return value;
-};
-const readStringProperty = (object, propertyName) => {
-    const property = Reflect.get(object, propertyName);
-    if (typeof property !== "string" || property.length === 0) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return property;
-};
-const readBooleanProperty = (object, propertyName) => {
-    const property = Reflect.get(object, propertyName);
-    if (typeof property !== "boolean") {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return property;
-};
-const readBytesProperty = (object, propertyName) => {
-    const property = Reflect.get(object, propertyName);
-    if (!(property instanceof Uint8Array)) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return property;
-};
-const readOptionalLengthProperty = (object, propertyName) => {
-    const property = Reflect.get(object, propertyName);
-    if (property === undefined) {
-        return undefined;
-    }
-    if (typeof property !== "number" || !Number.isSafeInteger(property) || property < 0) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    return property;
-};
-const readTagProperty = (object) => {
-    const tag = readStringProperty(object, "tag");
-    if (!validTags.has(tag)) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    switch (tag) {
-        case "encryption":
-        case "hash":
-        case "key":
-        case "multihash":
-        case "multikey":
-            return tag;
-        default:
-            throw new ReallyMeCryptoError("provider-failure");
-    }
-};
-const readKeyMaterialProperty = (object) => {
-    const keyMaterial = readStringProperty(object, "keyMaterial");
-    if (!validKeyMaterialKinds.has(keyMaterial)) {
-        throw new ReallyMeCryptoError("provider-failure");
-    }
-    switch (keyMaterial) {
-        case "not-key":
-        case "public-key":
-        case "private-key":
-        case "symmetric-key":
-            return keyMaterial;
-        default:
-            throw new ReallyMeCryptoError("provider-failure");
-    }
-};
-const readMulticodecMetadata = (value) => {
-    const object = requireObjectOutput(value);
-    const expectedKeyLength = readOptionalLengthProperty(object, "expectedKeyLength");
-    if (expectedKeyLength === undefined) {
-        return {
-            name: readStringProperty(object, "name"),
-            alg: readStringProperty(object, "alg"),
-            tag: readTagProperty(object),
-            keyMaterial: readKeyMaterialProperty(object),
-            prefix: readBytesProperty(object, "prefix"),
-        };
-    }
-    return {
-        name: readStringProperty(object, "name"),
-        alg: readStringProperty(object, "alg"),
-        tag: readTagProperty(object),
-        keyMaterial: readKeyMaterialProperty(object),
-        prefix: readBytesProperty(object, "prefix"),
-        expectedKeyLength,
-    };
-};
-const readParsedMultikey = (value) => {
-    const object = requireObjectOutput(value);
-    const expectedPublicKeyLength = readOptionalLengthProperty(object, "expectedPublicKeyLength");
-    if (expectedPublicKeyLength === undefined) {
-        return {
-            codecName: readStringProperty(object, "codecName"),
-            algorithmName: readStringProperty(object, "algorithmName"),
-            publicKey: readBytesProperty(object, "publicKey"),
-        };
-    }
-    return {
-        codecName: readStringProperty(object, "codecName"),
-        algorithmName: readStringProperty(object, "algorithmName"),
-        publicKey: readBytesProperty(object, "publicKey"),
-        expectedPublicKeyLength,
-    };
-};
-const readCidVerification = (value) => {
-    const object = requireObjectOutput(value);
-    return {
-        valid: readBooleanProperty(object, "valid"),
-        expectedCid: readStringProperty(object, "expectedCid"),
-        actualCid: readStringProperty(object, "actualCid"),
-    };
-};
-const asciiBytesToString = (bytes) => {
-    let value = "";
-    for (const byte of bytes) {
-        if (byte > 0x7f) {
-            throw new ReallyMeCryptoError("invalid-input");
-        }
-        value += String.fromCharCode(byte);
-    }
-    return value;
-};
-export const ReallyMeCodecs = {
-    base64urlEncode(bytes) {
-        ensureBytesInput(bytes);
-        return readStringOutput(requireReallyMeWasmProvider().base64urlEncode(bytes));
-    },
-    base64urlDecode(encoded) {
-        ensureStringInput(encoded);
-        return readBytesOutput(requireReallyMeWasmProvider().base64urlDecode(encoded));
-    },
-    base64urlDecodeBytes(encoded) {
-        ensureBytesInput(encoded);
-        return readBytesOutput(requireReallyMeWasmProvider().base64urlDecode(asciiBytesToString(encoded)));
-    },
-    multibaseBase64urlEncode(bytes) {
-        ensureBytesInput(bytes);
-        return readStringOutput(requireReallyMeWasmProvider().multibaseBase64urlEncode(bytes));
-    },
-    multibaseBase58btcEncode(bytes) {
-        ensureBytesInput(bytes);
-        return readStringOutput(requireReallyMeWasmProvider().multibaseBase58btcEncode(bytes));
-    },
-    multibaseDecode(encoded) {
-        ensureStringInput(encoded);
-        return readBytesOutput(requireReallyMeWasmProvider().multibaseDecode(encoded));
-    },
-    multicodecPrefixForName(codecName) {
-        ensureStringInput(codecName);
-        return readMulticodecMetadata(requireReallyMeWasmProvider().multicodecPrefixForName(codecName));
-    },
-    multicodecLookupPrefix(bytes) {
-        ensureBytesInput(bytes);
-        return readMulticodecMetadata(requireReallyMeWasmProvider().multicodecLookupPrefix(bytes));
-    },
-    multikeyEncode(codecName, publicKey) {
-        ensureStringInput(codecName);
-        ensureBytesInput(publicKey);
-        return readStringOutput(requireReallyMeWasmProvider().multikeyEncode(codecName, publicKey));
-    },
-    multikeyParse(multikey) {
-        ensureStringInput(multikey);
-        return readParsedMultikey(requireReallyMeWasmProvider().multikeyParse(multikey));
-    },
-    dagCborComputeCid(bytes) {
-        ensureBytesInput(bytes);
-        return readStringOutput(requireReallyMeWasmProvider().dagCborComputeCid(bytes));
-    },
-    dagCborVerifyCid(cid, bytes) {
-        ensureStringInput(cid);
-        ensureBytesInput(bytes);
-        return readCidVerification(requireReallyMeWasmProvider().dagCborVerifyCid(cid, bytes));
-    },
-};