@oxy.so/protocol 1.2.1 → 1.3.0

package/dist/esm/chain/engine.js

@@ -9,7 +9,7 @@
  * engine owns the verification + ordering policy.
  *
  * Storage and identity are both injected, so the engine has zero knowledge of
- * Mongo/SQLite, Oxy DIDs, or any app's lexicon — exactly what makes it reusable.
+ * the database, Oxy DIDs, or any app's lexicon — exactly what makes it reusable.
  */
 import { computeRecordId } from '../envelope/recordId.js';
 import { verifyEnvelope } from './verify.js';

package/dist/esm/chain/recordStore.js

@@ -4,8 +4,8 @@
  * The engine ({@link ./verify}, {@link ./engine}) is storage-agnostic: it owns
  * the verification state machine and continuity logic, and delegates EVERY read
  * and write to an injected {@link RecordStore}. An app supplies a store over its
- * own backend (oxy-api over Mongo `SignedRecord`/`RepoHead`, a node over SQLite,
- * Mention over its own Mongo) without the engine knowing anything Oxy- or
+ * own backend (oxy-api over Postgres `signed_records`/`repo_heads`, a node over
+ * SQLite, Mention over its own database) without the engine knowing anything Oxy- or
  * app-specific.
  *
  * All methods are **subject-keyed**: `subject` is the chain's subject DID
@@ -17,7 +17,7 @@
  * `append` MUST be atomic (record insert + head advance in one unit) and MUST
  * translate a duplicate-key collision on the unique `(subject, seq)` /
  * `recordId` index — i.e. a concurrent writer that already took this `seq` — into
- * `{ ok: false, reason: 'chain_conflict' }` (Mongo E11000 / SQLite
+ * `{ ok: false, reason: 'chain_conflict' }` (Postgres `23505` / SQLite
  * `SQLITE_CONSTRAINT`). That is the real multi-writer race guard; the engine's
  * pre-append continuity check is only the fast-path rejection.
  */

package/dist/esm/chain/verify.js

@@ -10,7 +10,8 @@
  *  - the {@link RecordStore} owns the monotonicity frontier + the chain head.
  *
  * The ordered checks (first failure wins):
- *  1. **shape** — the base `signedRecordEnvelopeSchema` (open `type`, opaque
+ *  1. **shape** — the base `signedRecordEnvelopeCheck`, the Zod-free twin of
+ *     `signedRecordEnvelopeSchema` (open `type`, opaque
  *     `record`). An app re-narrows `type` to its own set in its adapter.
  *  2. **signature** — `verifyEnvelopeSignature` recomputes the canonical signing
  *     input and checks the secp256k1 signature against the embedded `publicKey`.
@@ -24,7 +25,7 @@
  * subject?") is intentionally NOT here — it is an adapter-policy decision the
  * caller makes before invoking the engine, not a property of the envelope.
  */
-import { signedRecordEnvelopeSchema } from '@oxy.so/contracts';
+import { checkContract, signedRecordEnvelopeCheck } from '@oxy.so/contracts/client';
 import { verifyEnvelopeSignature } from '../envelope/sign.js';
 import { isAuthorizedKey } from '../identity/resolver.js';
 import { checkContinuity } from './continuity.js';
@@ -38,7 +39,7 @@ export const DEFAULT_CLOCK_SKEW_MS = 5 * 60 * 1000;
 export async function verifyEnvelope(store, resolver, env, opts = {}) {
     // 1. Base envelope shape (open `type`, `record` opaque). An app's adapter
     //    re-narrows `type` to its own accepted set before/around this call.
-    if (!signedRecordEnvelopeSchema.safeParse(env).success) {
+    if (checkContract(signedRecordEnvelopeCheck, env) === null) {
         return { ok: false, reason: 'invalid_envelope' };
     }
     // 2. Signature is internally consistent with the embedded `publicKey`. Cheap,
@@ -47,7 +48,10 @@ export async function verifyEnvelope(store, resolver, env, opts = {}) {
         return { ok: false, reason: 'bad_signature' };
     }
     // Enforce that v2 envelopes strictly contain required chain fields.
-    if (env.version === 2 && (typeof env.seq !== 'number' || typeof env.collection !== 'string' || typeof env.rkey !== 'string')) {
+    if (env.version === 2 &&
+        (typeof env.seq !== 'number' ||
+            typeof env.collection !== 'string' ||
+            typeof env.rkey !== 'string')) {
         return { ok: false, reason: 'invalid_envelope' };
     }
     // 3. The signing key is an authorized writer for the issuer (self-issued ⇒ a

package/dist/esm/envelope/sign.js

@@ -8,7 +8,7 @@
  */
 import { signedRecordSigningInput } from './signingInput.js';
 import { sha256 } from './recordId.js';
-import { deriveSecp256k1PublicKey, signSecp256k1Digest, verifySecp256k1Digest, } from '../secp256k1.js';
+import { deriveSecp256k1PublicKey, signSecp256k1Digest, verifySecp256k1Digest } from '../secp256k1.js';
 /** The one signature algorithm identifier the protocol emits. */
 const ALG = 'ES256K-DER-SHA256';
 /**

package/dist/esm/envelope/signingInput.js

@@ -23,7 +23,18 @@ export function signedRecordSigningInput(fields) {
     const { version, type, subject, issuer, record, issuedAt } = fields;
     if (version === 2) {
         const { seq, prev, collection, rkey } = fields;
-        return canonicalize({ version, type, subject, issuer, record, issuedAt, seq, prev, collection, rkey });
+        return canonicalize({
+            version,
+            type,
+            subject,
+            issuer,
+            record,
+            issuedAt,
+            seq,
+            prev,
+            collection,
+            rkey,
+        });
     }
     return canonicalize({ version, type, subject, issuer, record, issuedAt });
 }

package/dist/esm/identity/resolver.js

@@ -39,7 +39,8 @@ export function isAuthorizedKey(resolved, env) {
     if (resolved !== null &&
         resolved.custodialIssuer !== undefined &&
         env.issuer === resolved.custodialIssuer) {
-        return resolved.custodialPublicKey !== undefined && env.publicKey === resolved.custodialPublicKey
+        return resolved.custodialPublicKey !== undefined &&
+            env.publicKey === resolved.custodialPublicKey
             ? { ok: true }
             : { ok: false, reason: 'public_key_not_a_current_verification_method' };
     }

package/dist/esm/node/didWebResolver.js

@@ -60,9 +60,7 @@ function isSecp256k1Vm(vm) {
  * signatures verify against the hex key.
  */
 function collectCurrentPublicKeys(doc) {
-    const byId = new Map(doc.verificationMethod
-        .filter(isSecp256k1Vm)
-        .map((vm) => [vm.id, vm.publicKeyHex]));
+    const byId = new Map(doc.verificationMethod.filter(isSecp256k1Vm).map((vm) => [vm.id, vm.publicKeyHex]));
     const keys = [];
     for (const id of doc.assertionMethod) {
         const key = byId.get(id);

package/dist/esm/node/nodeApp.js

@@ -145,7 +145,9 @@ export function createNodeApp(deps) {
                 mode: config.mode,
                 version: config.protocolId,
                 serviceType: config.serviceType,
-                head: head && head.headRecordId !== null ? { seq: head.seq, headRecordId: head.headRecordId } : null,
+                head: head && head.headRecordId !== null
+                    ? { seq: head.seq, headRecordId: head.headRecordId }
+                    : null,
             });
         }
         catch (error) {
@@ -172,7 +174,9 @@ export function createNodeApp(deps) {
             const since = firstQueryValue(req.query.since);
             const limit = parseLimit(req.query.limit);
             const head = await store.getHead(subject);
-            const headWire = head && head.headRecordId !== null ? { seq: head.seq, headRecordId: head.headRecordId } : null;
+            const headWire = head && head.headRecordId !== null
+                ? { seq: head.seq, headRecordId: head.headRecordId }
+                : null;
             const sinceSeq = await resolveSinceSeq(store, subject, since);
             if (sinceSeq === null) {
                 res.json({ records: [], count: 0, head: headWire });
@@ -217,7 +221,9 @@ export function createNodeApp(deps) {
     app.post(NODE_SYNC_PUSH_PATH, writeRateLimit, jsonParser, async (req, res, next) => {
         try {
             const body = req.body;
-            const items = typeof body === 'object' && body !== null && Array.isArray(body.records)
+            const items = typeof body === 'object' &&
+                body !== null &&
+                Array.isArray(body.records)
                 ? body.records
                 : null;
             if (!items) {

package/dist/esm/node/nodeClient.js

@@ -11,7 +11,7 @@
  * response body is read with a hard byte ceiling, so a node cannot stream an
  * unbounded body into the caller.
  */
-import { readBoundedBytes, readBoundedJson, } from './httpFetch.js';
+import { readBoundedBytes, readBoundedJson } from './httpFetch.js';
 import { DEFAULT_CLIENT_MAX_REDIRECTS, DEFAULT_CLIENT_TIMEOUT_MS, DEFAULT_HEAD_MAX_BYTES, DEFAULT_LOG_MAX_BYTES, DEFAULT_MAX_BLOB_BYTES, DEFAULT_WRITE_RESPONSE_MAX_BYTES, NODE_BLOBS_PATH, NODE_HEAD_PATH, NODE_LOG_PATH, NODE_RECORDS_PATH, NODE_SYNC_PUSH_PATH, OWNER_AUTH_HEADERS, } from './constants.js';
 /** A non-2xx node response (or a node that returned a malformed body). */
 export class NodeClientError extends Error {
@@ -23,7 +23,9 @@ export class NodeClientError extends Error {
     }
 }
 function readError(body) {
-    if (typeof body === 'object' && body !== null && typeof body.error === 'string') {
+    if (typeof body === 'object' &&
+        body !== null &&
+        typeof body.error === 'string') {
         return body.error;
     }
     return undefined;
@@ -103,7 +105,10 @@ export class NodeClient {
             headRaw !== null &&
             typeof headRaw.seq === 'number' &&
             typeof headRaw.headRecordId === 'string'
-            ? { seq: headRaw.seq, headRecordId: headRaw.headRecordId }
+            ? {
+                seq: headRaw.seq,
+                headRecordId: headRaw.headRecordId,
+            }
             : null;
         return { records, count: records.length, head };
     }

package/dist/esm/platform/platform.js

@@ -25,5 +25,5 @@ export function isReactNative() {
  * `randomBytes`) and the `await import('node:crypto')` loader.
  */
 export function isNodeJS() {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
 }

package/dist/esm/secp256k1.js

@@ -6,14 +6,14 @@
  * RFC 6979 deterministic ECDSA signatures encoded as DER, and the 32-byte
  * ECDH x-coordinate. Callers never receive a library-specific key object.
  */
-import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 const HEX = /^[0-9a-fA-F]+$/;
 const COMPRESSED_PUBLIC_KEY = /^(02|03)[0-9a-fA-F]{64}$/;
 const UNCOMPRESSED_PUBLIC_KEY = /^04[0-9a-fA-F]{128}$/;
 function bytesToHex(bytes) {
-    let result = "";
+    let result = '';
     for (const byte of bytes) {
-        result += byte.toString(16).padStart(2, "0");
+        result += byte.toString(16).padStart(2, '0');
     }
     return result;
 }
@@ -32,16 +32,16 @@ function hexToBytes(value, label) {
  * The scalar must be within the secp256k1 order; zero and overflow are rejected.
  */
 export function normalizeSecp256k1PrivateKey(privateKeyHex) {
-    if (typeof privateKeyHex !== "string" ||
+    if (typeof privateKeyHex !== 'string' ||
         privateKeyHex.length === 0 ||
         privateKeyHex.length > 64 ||
         !HEX.test(privateKeyHex)) {
-        throw new Error("secp256k1 private key must contain 1 to 64 hexadecimal characters");
+        throw new Error('secp256k1 private key must contain 1 to 64 hexadecimal characters');
     }
-    const normalized = privateKeyHex.toLowerCase().padStart(64, "0");
-    const privateKey = hexToBytes(normalized, "secp256k1 private key");
+    const normalized = privateKeyHex.toLowerCase().padStart(64, '0');
+    const privateKey = hexToBytes(normalized, 'secp256k1 private key');
     if (!secp256k1.utils.isValidSecretKey(privateKey)) {
-        throw new Error("secp256k1 private key is outside the valid scalar range");
+        throw new Error('secp256k1 private key is outside the valid scalar range');
     }
     return normalized;
 }
@@ -56,24 +56,23 @@ export function isValidSecp256k1PrivateKey(privateKeyHex) {
     }
 }
 function parsePrivateKey(privateKeyHex) {
-    return hexToBytes(normalizeSecp256k1PrivateKey(privateKeyHex), "secp256k1 private key");
+    return hexToBytes(normalizeSecp256k1PrivateKey(privateKeyHex), 'secp256k1 private key');
 }
 function parsePublicKey(publicKeyHex) {
-    if (typeof publicKeyHex !== "string" ||
-        (!COMPRESSED_PUBLIC_KEY.test(publicKeyHex) &&
-            !UNCOMPRESSED_PUBLIC_KEY.test(publicKeyHex))) {
-        throw new Error("secp256k1 public key must be a compressed or uncompressed SEC1 hex key");
+    if (typeof publicKeyHex !== 'string' ||
+        (!COMPRESSED_PUBLIC_KEY.test(publicKeyHex) && !UNCOMPRESSED_PUBLIC_KEY.test(publicKeyHex))) {
+        throw new Error('secp256k1 public key must be a compressed or uncompressed SEC1 hex key');
     }
-    const publicKey = hexToBytes(publicKeyHex, "secp256k1 public key");
+    const publicKey = hexToBytes(publicKeyHex, 'secp256k1 public key');
     // Parsing validates the SEC1 prefix, coordinate range, and curve equation.
     secp256k1.Point.fromBytes(publicKey);
     return publicKey;
 }
 function parseDigest(digestHex) {
-    if (typeof digestHex !== "string" || digestHex.length !== 64) {
-        throw new Error("secp256k1 digest must be exactly 32 bytes of hexadecimal data");
+    if (typeof digestHex !== 'string' || digestHex.length !== 64) {
+        throw new Error('secp256k1 digest must be exactly 32 bytes of hexadecimal data');
     }
-    return hexToBytes(digestHex, "secp256k1 digest");
+    return hexToBytes(digestHex, 'secp256k1 digest');
 }
 /** True for a valid compressed or uncompressed SEC1 secp256k1 public key. */
 export function isValidSecp256k1PublicKey(publicKeyHex) {
@@ -113,17 +112,17 @@ export function signSecp256k1Digest(privateKeyHex, digestHex, options = {}) {
     const signature = secp256k1.sign(parseDigest(digestHex), parsePrivateKey(privateKeyHex), {
         lowS: options.lowS ?? false,
     });
-    return signature.toHex("der");
+    return signature.toHex('der');
 }
 /** Verify a DER-encoded ECDSA signature, accepting historical high-S signatures. */
 export function verifySecp256k1Digest(publicKeyHex, digestHex, signatureDerHex) {
     const publicKey = parsePublicKey(publicKeyHex);
     const digest = parseDigest(digestHex);
-    const signature = hexToBytes(signatureDerHex, "secp256k1 DER signature");
+    const signature = hexToBytes(signatureDerHex, 'secp256k1 DER signature');
     // Parse once up front so malformed or non-DER input is rejected explicitly.
-    secp256k1.Signature.fromBytes(signature, "der");
+    secp256k1.Signature.fromBytes(signature, 'der');
     return secp256k1.verify(signature, digest, publicKey, {
-        format: "der",
+        format: 'der',
         lowS: false,
     });
 }
@@ -137,24 +136,24 @@ export function verifySecp256k1Digest(publicKeyHex, digestHex, signatureDerHex)
 export function tweakAddSecp256k1PrivateKey(privateKeyHex, tweakHex) {
     const n = secp256k1.Point.Fn.ORDER;
     const key = BigInt(`0x${normalizeSecp256k1PrivateKey(privateKeyHex)}`);
-    if (typeof tweakHex !== "string" || tweakHex.length !== 64 || !HEX.test(tweakHex)) {
-        throw new Error("secp256k1 tweak must be exactly 32 bytes of hexadecimal data");
+    if (typeof tweakHex !== 'string' || tweakHex.length !== 64 || !HEX.test(tweakHex)) {
+        throw new Error('secp256k1 tweak must be exactly 32 bytes of hexadecimal data');
     }
     const tweak = BigInt(`0x${tweakHex}`);
     if (tweak >= n) {
-        throw new Error("secp256k1 tweak is not below the curve order");
+        throw new Error('secp256k1 tweak is not below the curve order');
     }
     const child = (key + tweak) % n;
     if (child === 0n) {
-        throw new Error("secp256k1 tweaked private key is zero");
+        throw new Error('secp256k1 tweaked private key is zero');
     }
-    return child.toString(16).padStart(64, "0");
+    return child.toString(16).padStart(64, '0');
 }
 /** Derive the fixed-width 32-byte ECDH x-coordinate shared secret. */
 export function deriveSecp256k1SharedSecret(privateKeyHex, publicKeyHex) {
     const encodedPoint = secp256k1.getSharedSecret(parsePrivateKey(privateKeyHex), parsePublicKey(publicKeyHex), true);
     if (encodedPoint.length !== 33) {
-        throw new Error("secp256k1 ECDH returned an unexpected point encoding");
+        throw new Error('secp256k1 ECDH returned an unexpected point encoding');
     }
     return encodedPoint.slice(1);
 }

package/dist/esm/sign.js

@@ -0,0 +1,10 @@
+/**
+ * `@oxy.so/protocol/sign` — message and envelope signatures (secp256k1).
+ *
+ * The same functions the root entry exports, on their own entry so a client
+ * can load the signer (and `@noble/curves` under it) where it signs — inside
+ * `@oxy.so/core/crypto`, which apps load on first use — while the root entry
+ * it imports at startup for hashing and platform loaders stays free of the
+ * curve library once a bundler drops the root's unused re-exports.
+ */
+export { signEnvelope, signMessage, verifyEnvelopeSignature, verifySignature, } from './envelope/sign.js';