@oxy.so/protocol 1.2.2 → 1.3.0

package/dist/cjs/chain/engine.js

@@ -10,7 +10,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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyAndAppend = verifyAndAppend;

package/dist/cjs/chain/recordStore.js

@@ -5,8 +5,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
@@ -18,7 +18,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/cjs/chain/verify.js

@@ -11,7 +11,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`.
@@ -28,7 +29,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CLOCK_SKEW_MS = void 0;
 exports.verifyEnvelope = verifyEnvelope;
-const contracts_1 = require("@oxy.so/contracts");
+const client_1 = require("@oxy.so/contracts/client");
 const sign_1 = require("../envelope/sign");
 const resolver_1 = require("../identity/resolver");
 const continuity_1 = require("./continuity");
@@ -42,7 +43,7 @@ exports.DEFAULT_CLOCK_SKEW_MS = 5 * 60 * 1000;
 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 (!contracts_1.signedRecordEnvelopeSchema.safeParse(env).success) {
+    if ((0, client_1.checkContract)(client_1.signedRecordEnvelopeCheck, env) === null) {
         return { ok: false, reason: 'invalid_envelope' };
     }
     // 2. Signature is internally consistent with the embedded `publicKey`. Cheap,
@@ -51,7 +52,10 @@ 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/cjs/envelope/signingInput.js

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

package/dist/cjs/identity/resolver.js

@@ -42,7 +42,8 @@ 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/cjs/node/didWebResolver.js

@@ -64,9 +64,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/cjs/node/nodeApp.js

@@ -153,7 +153,9 @@ 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) {
@@ -180,7 +182,9 @@ 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 });
@@ -225,7 +229,9 @@ function createNodeApp(deps) {
     app.post(constants_1.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/cjs/node/nodeClient.js

@@ -28,7 +28,9 @@ class NodeClientError extends Error {
 }
 exports.NodeClientError = NodeClientError;
 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;
@@ -108,7 +110,10 @@ 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/cjs/platform/platform.js

@@ -29,5 +29,5 @@ function isReactNative() {
  * `randomBytes`) and the `await import('node:crypto')` loader.
  */
 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/cjs/secp256k1.js

@@ -23,9 +23,9 @@ 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;
 }
@@ -44,16 +44,16 @@ function hexToBytes(value, label) {
  * The scalar must be within the secp256k1 order; zero and overflow are rejected.
  */
 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_js_1.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;
 }
@@ -68,24 +68,23 @@ 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_js_1.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. */
 function isValidSecp256k1PublicKey(publicKeyHex) {
@@ -125,17 +124,17 @@ function signSecp256k1Digest(privateKeyHex, digestHex, options = {}) {
     const signature = secp256k1_js_1.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. */
 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_js_1.secp256k1.Signature.fromBytes(signature, "der");
+    secp256k1_js_1.secp256k1.Signature.fromBytes(signature, 'der');
     return secp256k1_js_1.secp256k1.verify(signature, digest, publicKey, {
-        format: "der",
+        format: 'der',
         lowS: false,
     });
 }
@@ -149,24 +148,24 @@ function verifySecp256k1Digest(publicKeyHex, digestHex, signatureDerHex) {
 function tweakAddSecp256k1PrivateKey(privateKeyHex, tweakHex) {
     const n = secp256k1_js_1.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. */
 function deriveSecp256k1SharedSecret(privateKeyHex, publicKeyHex) {
     const encodedPoint = secp256k1_js_1.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/cjs/sign.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * `@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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = exports.verifyEnvelopeSignature = exports.signMessage = exports.signEnvelope = void 0;
+var sign_1 = require("./envelope/sign");
+Object.defineProperty(exports, "signEnvelope", { enumerable: true, get: function () { return sign_1.signEnvelope; } });
+Object.defineProperty(exports, "signMessage", { enumerable: true, get: function () { return sign_1.signMessage; } });
+Object.defineProperty(exports, "verifyEnvelopeSignature", { enumerable: true, get: function () { return sign_1.verifyEnvelopeSignature; } });
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return sign_1.verifySignature; } });