@oxy.so/protocol 1.0.0

package/dist/types/platform/crypto.native.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Platform Crypto / Storage — React Native Variant
+ *
+ * Companion to `./crypto.ts`. See the doc-comment at the top of that file for
+ * the full design.
+ *
+ * Metro auto-selects this file in any non-web build (`preferNativePlatform`
+ * is `true` for iOS / Android, so `*.native.js` shadows `*.js` during
+ * source-extension resolution inside `node_modules/@oxy.so/protocol/dist/`). On
+ * iOS / Android `<base>.ios.js` / `<base>.android.js` would shadow this file
+ * if they existed, but they don't — `.native.js` is the shared RN variant.
+ *
+ *   - The default variant references Node's `'crypto'` and would crash Metro
+ *     if bundled into an RN app.
+ *   - This variant references the RN-only modules (`expo-crypto`,
+ *     `expo-secure-store`, `@react-native-async-storage/async-storage`),
+ *     each behind Metro's optional-dependency mechanism (see below).
+ *
+ * Both variants expose the same surface; importers don't care which one
+ * they got.
+ *
+ * # Why `try { require('literal') } catch` and not a static import?
+ *
+ * Those three RN modules are declared OPTIONAL peer dependencies in
+ * `package.json`. A static `import` contradicts that: an optional peer that is
+ * omitted does not degrade, it fails to RESOLVE, and Metro aborts the whole
+ * bundle. Because `@oxy.so/core`'s `crypto/polyfill` imports `@oxy.so/protocol`
+ * from its root entry, this file is in the eager graph of EVERY React Native
+ * app on `@oxy.so/core` — so a single undeclared optional peer broke the native
+ * bundle of every app that did not happen to install it, with a resolution
+ * error pointing at a dependency the app never mentions.
+ *
+ * Metro treats a `require()` of a STRING LITERAL that sits inside a `try`
+ * block as an optional dependency: it resolves it when present, and when
+ * absent emits a stub that throws on evaluation instead of failing the build.
+ * The `catch` turns that into a `null` module handle, and the loader below
+ * throws an actionable error naming the missing package the first time the
+ * capability is actually used. Bundle-time hard failure becomes a
+ * capability-scoped runtime failure — which is exactly what "optional peer"
+ * is supposed to mean.
+ *
+ * Two constraints this shape has to respect, both learned the hard way:
+ *
+ *   - The specifier MUST be a literal. A runtime-computed `require(variable)`
+ *     is unresolvable for Metro (that is the bug the shared-identity bridge
+ *     below documents) and silently yields nothing in a consuming repo.
+ *   - The load MUST stay synchronous. `getRandomBytesRN` backs
+ *     `globalThis.crypto.getRandomValues` in `@oxy.so/core`'s polyfill, which
+ *     cannot await anything.
+ *
+ * `expo-modules-core` is a NON-optional peer (every RN app has it via `expo`),
+ * so it stays a plain static import.
+ */
+import type { ExpoCryptoLike, ExpoSecureStoreLike, SharedIdentityBridge } from './expoTypes';
+export type { ExpoCryptoLike, ExpoSecureStoreLike, SharedIdentityBridge };
+/** Persistent KV storage surface used from `@react-native-async-storage/async-storage`. */
+type AsyncStorageLike = {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+};
+export declare function loadNodeCrypto(): Promise<typeof import('crypto')>;
+export declare function loadExpoCrypto(): Promise<ExpoCryptoLike>;
+export declare function loadSecureStore(): Promise<ExpoSecureStoreLike>;
+export declare function loadAsyncStorage(): Promise<{
+    default: AsyncStorageLike;
+}>;
+/**
+ * Synchronous random-bytes via `expo-crypto.getRandomBytes`.
+ *
+ * Synchronous by contract: `@oxy.so/core`'s crypto polyfill uses this to back
+ * `globalThis.crypto.getRandomValues`, which cannot await. That is why
+ * `expo-crypto` is resolved with a synchronous `require` at module scope rather
+ * than a dynamic `import()`.
+ */
+export declare function getRandomBytesRN(byteCount: number): Uint8Array;
+export declare function loadSharedIdentityBridge(): Promise<SharedIdentityBridge | null>;

package/dist/types/platform/expoTypes.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Structural interfaces for Expo platform modules.
+ *
+ * These replace `typeof import('expo-crypto')` and
+ * `typeof import('expo-secure-store')` in the built declaration files of
+ * `@oxy.so/protocol` and `@oxy.so/core`.
+ *
+ * ## Why structural interfaces instead of `typeof import('expo-*')`?
+ *
+ * Under NodeNext module resolution (used by `@oxy.so/api` and `@oxy.so/node`),
+ * `expo-crypto` ships with `"exports": {}` (empty exports map). TypeScript
+ * traverses into the package anyway via the `types` field, which transitively
+ * loads `expo-modules-core`. That pollution makes `setInterval`/`setTimeout`
+ * resolve to DOM's `number` return type rather than Node's `NodeJS.Timeout`,
+ * producing ~10 spurious `TS2322` / `TS2339` errors in every consumer that
+ * uses Node timer APIs — none of which reference protocol types at all.
+ *
+ * Structural interfaces break the transitive expo-modules-core dependency
+ * entirely: consumers that don't have Expo installed see clean types, and
+ * the actual RN runtime (which DOES have Expo installed) still works because
+ * the real modules satisfy these interfaces structurally.
+ */
+/**
+ * Minimal structural interface for the subset of `expo-crypto` used by
+ * `@oxy.so/protocol` (SHA-256 hashing in RN) and `@oxy.so/core` (key-manager
+ * random-byte generation).
+ *
+ * The real `expo-crypto` namespace satisfies this interface structurally.
+ */
+export interface ExpoCryptoLike {
+    /** Generate `byteCount` cryptographically-random bytes synchronously. */
+    getRandomBytes(byteCount: number): Uint8Array;
+    /** Generate `byteCount` cryptographically-random bytes asynchronously. */
+    getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
+    /**
+     * Compute a digest of `data` using the given `algorithm` string
+     * (e.g. `CryptoDigestAlgorithm.SHA256`). Used by `recordId.ts` in the
+     * React Native runtime path for content-address hashing.
+     */
+    digestStringAsync(algorithm: string, data: string, options?: unknown): Promise<string>;
+    /**
+     * Algorithm constants (e.g. `CryptoDigestAlgorithm.SHA256 === 'SHA-256'`).
+     * Represented as a plain string-keyed record so the interface does not
+     * depend on the enum definition inside expo-crypto.
+     */
+    readonly CryptoDigestAlgorithm: Record<string, string>;
+}
+/**
+ * Minimal structural interface for the subset of `expo-secure-store` used by
+ * `@oxy.so/core` `KeyManager` for on-device identity storage.
+ *
+ * The real `expo-secure-store` namespace satisfies this interface structurally.
+ *
+ * `options` are typed as `object` (rather than the concrete `SecureStoreOptions`
+ * from expo-secure-store) so callers can pass any plain options bag without
+ * importing expo-secure-store's type declarations. TypeScript method bivariance
+ * makes the real `setItemAsync(opts?: SecureStoreOptions)` compatible with this
+ * `setItemAsync(opts?: object)` signature.
+ */
+export interface ExpoSecureStoreLike {
+    setItemAsync(key: string, value: string, options?: object): Promise<void>;
+    getItemAsync(key: string, options?: object): Promise<string | null>;
+    deleteItemAsync(key: string, options?: object): Promise<void>;
+    /**
+     * Keychain / Keystore accessibility constant: item accessible only when the
+     * device is unlocked, and only on this device (no iCloud backup).
+     * Value: `KeychainAccessibilityConstant` (a number alias in expo-secure-store).
+     */
+    readonly WHEN_UNLOCKED_THIS_DEVICE_ONLY: number;
+    /**
+     * Keychain / Keystore accessibility constant: item accessible whenever the
+     * device is unlocked (may be restored to a different device via backup).
+     */
+    readonly WHEN_UNLOCKED: number;
+}
+/**
+ * Structural interface for the `@oxy.so/expo-oxy-identity` native module — the
+ * cross-app shared Oxy identity bridge.
+ *
+ * On Android the keypair crosses the process boundary through a
+ * signature-protected `ContentProvider` hosted by Commons; on iOS every method
+ * is a no-op (the Keychain Access Group path in `@oxy.so/core`'s `KeyManager`
+ * owns iOS sharing). Typed structurally here so `@oxy.so/protocol` and
+ * `@oxy.so/core` can reference the bridge without a hard dependency on the
+ * optional native module.
+ */
+export interface SharedIdentityBridge {
+    /** Read the shared keypair, or null when none is available on this device. */
+    getShared(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    } | null>;
+    /** Persist the shared keypair into this app's hardware-backed store (Commons only). */
+    putShared(privateKey: string, publicKey: string): Promise<void>;
+    /** Whether a shared identity is readable on this device. */
+    hasShared(): Promise<boolean>;
+    /** Remove the shared identity from this app's local store (best-effort). */
+    clearShared(): Promise<void>;
+}

package/dist/types/platform/platform.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Platform Detection — runtime predicates.
+ *
+ * Detects the host runtime WITHOUT importing from 'react-native', so the
+ * protocol's crypto modules can be used in web / Node.js / React Native
+ * environments without bundlers failing on react-native imports.
+ *
+ * Only the two predicates the protocol's platform-crypto loaders need live
+ * here. Richer platform detection (`getPlatformOS`, `isWeb`, `isNative`, …)
+ * is an SDK concern and stays in `@oxy.so/core`.
+ */
+/**
+ * Check if running in React Native.
+ *
+ * Selects the React Native crypto variant (`expo-crypto` /
+ * `expo-secure-store` / async-storage) over the Node/web variant.
+ */
+export declare function isReactNative(): boolean;
+/**
+ * Check if running in Node.js.
+ *
+ * Gates use of Node's built-in `crypto` (the synchronous SHA-256 path and
+ * `randomBytes`) and the `await import('node:crypto')` loader.
+ */
+export declare function isNodeJS(): boolean;

package/dist/types/secp256k1.d.ts

@@ -0,0 +1,45 @@
+/**
+ * secp256k1 primitives shared by every Oxy runtime.
+ *
+ * This module owns the curve binding and the wire formats used across Oxy:
+ * 32-byte private keys, compressed or uncompressed SEC1 public keys,
+ * RFC 6979 deterministic ECDSA signatures encoded as DER, and the 32-byte
+ * ECDH x-coordinate. Callers never receive a library-specific key object.
+ */
+export interface Secp256k1KeyPair {
+    /** Canonical lowercase 32-byte scalar. */
+    privateKey: string;
+    /** Lowercase uncompressed SEC1 public key (65 bytes). */
+    publicKey: string;
+}
+export interface Secp256k1SignatureOptions {
+    /** Normalize S into the lower half of the curve order. Defaults to false for wire compatibility. */
+    lowS?: boolean;
+}
+/**
+ * Normalize a legacy short/cased scalar to canonical 32-byte lowercase hex.
+ * The scalar must be within the secp256k1 order; zero and overflow are rejected.
+ */
+export declare function normalizeSecp256k1PrivateKey(privateKeyHex: string): string;
+/** True when a value is a valid secp256k1 scalar (legacy short hex accepted). */
+export declare function isValidSecp256k1PrivateKey(privateKeyHex: string): boolean;
+/** True for a valid compressed or uncompressed SEC1 secp256k1 public key. */
+export declare function isValidSecp256k1PublicKey(publicKeyHex: string): boolean;
+/** Generate a canonical private key and its uncompressed public key. */
+export declare function generateSecp256k1KeyPair(): Secp256k1KeyPair;
+/** Derive a compressed or uncompressed SEC1 public key from a private scalar. */
+export declare function deriveSecp256k1PublicKey(privateKeyHex: string, compressed?: boolean): string;
+/** Parse and re-encode a public key in canonical lowercase SEC1 form. */
+export declare function normalizeSecp256k1PublicKey(publicKeyHex: string, compressed?: boolean): string;
+/**
+ * Sign a 32-byte digest with deterministic RFC 6979 ECDSA and return DER hex.
+ *
+ * `lowS` defaults to false because historical Oxy signatures used elliptic's
+ * default and therefore may occupy either half of the curve order. Verification
+ * accepts both forms; callers that require low-S normalization opt in explicitly.
+ */
+export declare function signSecp256k1Digest(privateKeyHex: string, digestHex: string, options?: Secp256k1SignatureOptions): string;
+/** Verify a DER-encoded ECDSA signature, accepting historical high-S signatures. */
+export declare function verifySecp256k1Digest(publicKeyHex: string, digestHex: string, signatureDerHex: string): boolean;
+/** Derive the fixed-width 32-byte ECDH x-coordinate shared secret. */
+export declare function deriveSecp256k1SharedSecret(privateKeyHex: string, publicKeyHex: string): Uint8Array;

package/dist/types/transparency/checkpoint.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Transparency checkpoint — the signed, hash-linked commitment to a tree root.
+ *
+ * A checkpoint is what the operator PUBLISHES: "at `periodEnd` I committed to
+ * `root` over `treeSize` subjects, and the previous checkpoint hashed to
+ * `prevCheckpointHash`". The `prevCheckpointHash` link makes the checkpoint
+ * sequence itself append-only: once any checkpoint is anchored publicly, none of
+ * its ancestors can be rewritten without breaking the chain of hashes.
+ *
+ * ## Why the signature covers ONLY the five fields
+ *
+ * The signing input is derived from exactly `{index, periodEnd, treeSize, root,
+ * prevCheckpointHash}` — never from the surrounding storage document, and never
+ * from other signatures. That is what makes a checkpoint CO-SIGNABLE: the
+ * operator and any number of independent witnesses (e.g. user-run
+ * `@oxy.so/node` deployments) each sign the identical bytes with their own key,
+ * with zero coordination and in any order. Two conflicting roots for one
+ * `index`, each carrying valid signatures, is then transferable proof of
+ * equivocation that needs no cooperation from the operator to demonstrate.
+ *
+ * Extra fields on the object passed in are ignored by design, so handing this a
+ * database document cannot change what was signed.
+ */
+/** The one signature algorithm the protocol emits. */
+declare const ALG: "ES256K-DER-SHA256";
+/** The signed body of a checkpoint. */
+export interface TransparencyCheckpointFields {
+    /** Monotonic checkpoint number; gapless. */
+    index: number;
+    /** End of the period this checkpoint commits to (ms epoch). */
+    periodEnd: number;
+    /** Number of leaves (subjects) committed. */
+    treeSize: number;
+    /** The Merkle root over the committed heads. */
+    root: string;
+    /** {@link checkpointHash} of the previous checkpoint; `null` at the first one. */
+    prevCheckpointHash: string | null;
+}
+/** One signer's endorsement of a checkpoint — the operator's or a witness's. */
+export interface TransparencyCheckpointSignature {
+    /** Uncompressed hex public key of the signer. */
+    publicKey: string;
+    alg: typeof ALG;
+    /** DER-encoded hex secp256k1 signature over {@link checkpointSigningInput}. */
+    signature: string;
+}
+/**
+ * The exact bytes every co-signer signs: the canonical JSON of the five signed
+ * fields under the checkpoint domain prefix. Key order in the input object is
+ * irrelevant; extra properties are dropped.
+ */
+export declare function checkpointSigningInput(fields: TransparencyCheckpointFields): string;
+/**
+ * The content address of a checkpoint — what the NEXT checkpoint's
+ * `prevCheckpointHash` references.
+ */
+export declare function checkpointHash(fields: TransparencyCheckpointFields): Promise<string>;
+/**
+ * Sign a checkpoint with an explicit private key. Used by the operator and,
+ * identically, by every witness that co-signs the same checkpoint.
+ */
+export declare function signCheckpoint(fields: TransparencyCheckpointFields, privateKeyHex: string): Promise<TransparencyCheckpointSignature>;
+/**
+ * Verify one signature over a checkpoint's signed fields.
+ *
+ * Confirms the signature matches the embedded `publicKey` for exactly these
+ * fields. It does NOT establish that the key belongs to a trusted operator or an
+ * accepted witness — that policy lives with the verifier's key list.
+ */
+export declare function verifyCheckpointSignature(fields: TransparencyCheckpointFields, signature: TransparencyCheckpointSignature): Promise<boolean>;
+export {};

package/dist/types/transparency/tree.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Transparency Merkle tree — leaf hashing, root computation, and inclusion
+ * proofs over a snapshot of chain heads.
+ *
+ * ## What this is for
+ *
+ * A per-subject hash chain proves nobody edited a record. It does NOT prove the
+ * SERVER didn't serve two different histories to two parties (equivocation), or
+ * quietly drop a record. That gap is closed by committing to every subject's
+ * chain head at once, publishing the commitment, and letting anyone verify that
+ * their own head is inside it — which is exactly what this tree does. The
+ * commitment (the root) is what gets signed into a checkpoint (`./checkpoint`)
+ * and anchored on a public chain.
+ *
+ * ## Shape
+ *
+ * The tree follows RFC 6962 (Certificate Transparency) so the algorithms are
+ * standard and independently reimplementable: leaves and interior nodes are
+ * hashed under DISTINCT domain prefixes (a leaf hash can never be reinterpreted
+ * as an interior node), an odd level splits so the LEFT subtree is the largest
+ * power of two below the size, and a single-leaf tree's root is the leaf itself.
+ *
+ * A built tree keeps every LEVEL, not just its leaves, because that is what
+ * makes serving proofs cheap: {@link inclusionProof} reads siblings straight out
+ * of the levels instead of re-hashing subtrees, so one build amortizes over all
+ * the proofs cut from it (a checkpoint is built once and proved thousands of
+ * times, once per subject that audits it).
+ *
+ * Crucially, {@link verifyInclusionProof} needs only the verifier's OWN leaf,
+ * its index, the tree size, the audit path, and the signed root — never the
+ * other leaves. So a device or node can audit its own history against a
+ * published checkpoint without downloading anyone else's data.
+ *
+ * The leaf order is fixed by {@link buildTransparencyTreeFromHeads}: ascending
+ * by `subjectDid` in UTF-16 code-unit order. Order is part of the commitment, so
+ * every implementation MUST sort identically or the roots diverge.
+ */
+/**
+ * The root of a tree with zero leaves: `sha256("oxy.transparency.empty.v1")`.
+ *
+ * Hard-coded because hashing is async and this is needed as a value; a Jest
+ * regression test pins it against the live hash of {@link EMPTY_PREIMAGE}.
+ */
+export declare const EMPTY_TRANSPARENCY_ROOT = "315338df4bc34de7d057b583a082268016888323c79c0376586406a64f441b1e";
+/**
+ * One subject's committed chain position: the head of their signed-record chain
+ * at the moment the snapshot was taken. Mirrors the `RepoHead` row an app keeps.
+ */
+export interface TransparencyHeadEntry {
+    /** The chain's subject DID (`did:web:<domain>:u:<userId>`). */
+    subjectDid: string;
+    /** The `seq` of the head record. */
+    seq: number;
+    /** The `recordId` (content address) of the head record. */
+    headRecordId: string;
+}
+/** A built tree: its commitment plus every level proofs are cut from. */
+export interface TransparencyTree {
+    root: string;
+    treeSize: number;
+    /**
+     * Every level bottom-up: `levels[0]` is the leaf hashes in committed order,
+     * each next level is the one below it paired up, and the last is `[root]`
+     * (empty for a zero-leaf tree).
+     */
+    levels: string[][];
+}
+/** A tree built from head entries, with the leaf index of every subject. */
+export interface TransparencyTreeFromHeads extends TransparencyTree {
+    /** `subjectDid` → leaf index, so a proof can be served by subject. */
+    indexBySubject: Record<string, number>;
+}
+/** Arguments for {@link verifyInclusionProof}. */
+export interface InclusionProofCheck {
+    /** The verifier's own leaf hash ({@link transparencyLeafHash}). */
+    leaf: string;
+    /** The leaf's index in the committed order. */
+    index: number;
+    /** The `treeSize` the checkpoint committed to. */
+    treeSize: number;
+    /** The audit path, leaf-adjacent sibling first. */
+    proof: string[];
+    /** The root the checkpoint committed to. */
+    root: string;
+}
+/**
+ * Hash one subject's head into a leaf.
+ *
+ * The pre-image is the canonical JSON of the three committed fields under the
+ * leaf domain prefix — so a DID containing a delimiter-like character cannot
+ * forge another subject's leaf (JSON escaping makes the encoding unambiguous),
+ * and a leaf can never collide with an interior node.
+ */
+export declare function transparencyLeafHash(entry: TransparencyHeadEntry): Promise<string>;
+/**
+ * Build a tree over already-hashed leaves, in the given order.
+ *
+ * Levels are built bottom-up, each one pairing the level below and carrying a
+ * trailing odd node up unchanged — which yields exactly RFC 6962's tree, whose
+ * recursive definition splits at the largest power of two below the size.
+ * `transparency.test.ts` pins that equivalence against a direct transcription of
+ * the RFC's MTH for every size up to 40, so the shape can never silently drift.
+ *
+ * The order IS part of the commitment — prefer
+ * {@link buildTransparencyTreeFromHeads}, which owns the canonical ordering.
+ */
+export declare function buildTransparencyTree(leaves: string[]): Promise<TransparencyTree>;
+/**
+ * Build the canonical tree for a snapshot of chain heads.
+ *
+ * Sorts ascending by `subjectDid` in UTF-16 code-unit order — NEVER
+ * `localeCompare`, whose order is locale-dependent and would make two
+ * verifiers compute different roots from identical data.
+ *
+ * Throws on a duplicate `subjectDid`: a snapshot must commit to exactly one head
+ * per subject, and silently keeping one of two would hide the other's history.
+ */
+export declare function buildTransparencyTreeFromHeads(entries: TransparencyHeadEntry[]): Promise<TransparencyTreeFromHeads>;
+/**
+ * The audit path proving `index` is committed in `tree` (RFC 6962 PATH): each
+ * step is the sibling subtree hash, leaf-adjacent first.
+ *
+ * Pure index arithmetic over the tree's levels — no hashing, so cutting a proof
+ * costs O(log n) array reads however large the checkpoint is.
+ */
+export declare function inclusionProof(tree: TransparencyTree, index: number): string[];
+/**
+ * Verify an audit path against a committed root (RFC 6962 §2.1.1).
+ *
+ * Recomputes the root from the leaf upward using only the path, so the verifier
+ * never needs another subject's data. Returns `false` for every failure mode —
+ * tampered leaf, replayed index, truncated path, foreign root — rather than
+ * throwing, so callers treat auditing as a boolean.
+ */
+export declare function verifyInclusionProof(check: InclusionProofCheck): Promise<boolean>;

package/package.json

@@ -0,0 +1,157 @@
+{
+  "name": "@oxy.so/protocol",
+  "version": "1.0.0",
+  "description": "Oxy Protocol — the app-agnostic base substrate: signed-record envelope, canonical JSON, signature/verification, and platform crypto. Reused by any Oxy app to decentralize its own content.",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "secp256k1": [
+        "dist/types/secp256k1.d.ts"
+      ],
+      "node": [
+        "dist/types/node/index.d.ts"
+      ]
+    }
+  },
+  "source": "src/index.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "react-native": "./dist/esm/index.js",
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./node": {
+      "import": {
+        "types": "./dist/types/node/index.d.ts",
+        "default": "./dist/esm/node/index.js"
+      },
+      "require": {
+        "types": "./dist/types/node/index.d.ts",
+        "default": "./dist/cjs/node/index.js"
+      },
+      "default": "./dist/esm/node/index.js"
+    },
+    "./secp256k1": {
+      "react-native": "./dist/esm/secp256k1.js",
+      "import": {
+        "types": "./dist/types/secp256k1.d.ts",
+        "default": "./dist/esm/secp256k1.js"
+      },
+      "require": {
+        "types": "./dist/types/secp256k1.d.ts",
+        "default": "./dist/cjs/secp256k1.js"
+      },
+      "default": "./dist/esm/secp256k1.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "react-native": {
+    "./dist/esm/platform/crypto.js": "./dist/esm/platform/crypto.native.js",
+    "./dist/cjs/platform/crypto.js": "./dist/cjs/platform/crypto.native.js"
+  },
+  "files": [
+    "NOTICE",
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "oxyhq",
+    "protocol",
+    "signed-records",
+    "canonical-json",
+    "crypto",
+    "did"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oxyhq/sdk",
+    "directory": "packages/protocol"
+  },
+  "author": "OxyHQ",
+  "license": "Apache-2.0",
+  "homepage": "https://oxy.so",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "bun run build:cjs && bun run build:esm && bun run build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node scripts/fix-esm-imports.mjs",
+    "build:types": "tsc -p tsconfig.types.json",
+    "clean": "rm -rf dist",
+    "typescript": "tsc --noEmit",
+    "test": "jest --passWithNoTests",
+    "lint": "biome lint --error-on-warnings ./src",
+    "prepublishOnly": "node ../../scripts/assert-bun-publish.mjs && bun run clean && bun run build",
+    "release": "rm -rf dist && bun run build && release-it"
+  },
+  "release-it": {
+    "git": {
+      "tagName": "@oxy.so/protocol@${version}",
+      "tagAnnotation": "Release @oxy.so/protocol@${version}",
+      "commitMessage": "chore(protocol): release @oxy.so/protocol@${version}"
+    },
+    "github": {
+      "release": true,
+      "releaseName": "@oxy.so/protocol@${version}"
+    },
+    "npm": {
+      "publish": true
+    }
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.7",
+    "@oxy.so/contracts": "^1.0.0",
+    "zod": "^3.25.64"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "*",
+    "expo-crypto": "*",
+    "expo-secure-store": "*",
+    "express": "^4.18.0 || ^5.0.0",
+    "expo-modules-core": "*"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    },
+    "expo-crypto": {
+      "optional": true
+    },
+    "expo-secure-store": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@types/express": "^4.17.25",
+    "@types/node": "^22.20.1",
+    "@types/supertest": "^6.0.2",
+    "expo-crypto": "~56.0.3",
+    "expo-modules-core": "~57.0.17",
+    "expo-secure-store": "~56.0.4",
+    "express": "^4.22.2",
+    "jest": "^30.5.1",
+    "release-it": "^19.0.6",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.9.2"
+  }
+}