@oxy.so/protocol 1.2.2 → 1.3.1

package/src/chain/verify.ts

@@ -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`.
@@ -25,7 +26,8 @@
  * caller makes before invoking the engine, not a property of the envelope.
  */
 
-import { signedRecordEnvelopeSchema, type SignedRecordEnvelope } from '@oxy.so/contracts';
+import type { SignedRecordEnvelope } from '@oxy.so/contracts';
+import { checkContract, signedRecordEnvelopeCheck } from '@oxy.so/contracts/client';
 import { verifyEnvelopeSignature } from '../envelope/sign';
 import { isAuthorizedKey, type VerificationMethodResolver } from '../identity/resolver';
 import { checkContinuity } from './continuity';
@@ -56,7 +58,7 @@ export async function verifyEnvelope(
 ): Promise<VerifyOutcome> {
   // 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' };
   }
 
@@ -67,7 +69,12 @@ export async function verifyEnvelope(
   }
 
   // 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' };
   }
 

package/src/envelope/recordId.ts

@@ -23,10 +23,7 @@ export async function sha256(message: string): Promise<string> {
   // In React Native, use expo-crypto
   if (isReactNative()) {
     const Crypto = await loadExpoCrypto();
-    return Crypto.digestStringAsync(
-      Crypto.CryptoDigestAlgorithm.SHA256,
-      message,
-    );
+    return Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, message);
   }
 
   if (isNodeJS()) {

package/src/envelope/sign.ts

@@ -10,11 +10,7 @@
 import type { SignedRecordEnvelope } from '@oxy.so/contracts';
 import { signedRecordSigningInput, type SignedRecordSigningFields } from './signingInput';
 import { sha256 } from './recordId';
-import {
-  deriveSecp256k1PublicKey,
-  signSecp256k1Digest,
-  verifySecp256k1Digest,
-} from '../secp256k1';
+import { deriveSecp256k1PublicKey, signSecp256k1Digest, verifySecp256k1Digest } from '../secp256k1';
 
 /** The one signature algorithm identifier the protocol emits. */
 const ALG = 'ES256K-DER-SHA256' as const;
@@ -82,5 +78,9 @@ export async function signEnvelope(
  * server / node owner check.
  */
 export async function verifyEnvelopeSignature(envelope: SignedRecordEnvelope): Promise<boolean> {
-  return verifySignature(signedRecordSigningInput(envelope), envelope.signature, envelope.publicKey);
+  return verifySignature(
+    signedRecordSigningInput(envelope),
+    envelope.signature,
+    envelope.publicKey,
+  );
 }

package/src/envelope/signingInput.ts

@@ -42,7 +42,18 @@ export function signedRecordSigningInput(fields: SignedRecordSigningFields): str
   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/src/identity/resolver.ts

@@ -50,7 +50,13 @@ export interface VerificationMethodResolver {
 /** Verdict of the key-authorization decision (a subset of {@link RejectionReason}). */
 export type KeyAuthorization =
   | { ok: true }
-  | { ok: false; reason: Extract<RejectionReason, 'public_key_not_a_current_verification_method' | 'untrusted_issuer'> };
+  | {
+      ok: false;
+      reason: Extract<
+        RejectionReason,
+        'public_key_not_a_current_verification_method' | 'untrusted_issuer'
+      >;
+    };
 
 /**
  * Decide whether `env`'s signing key (`env.publicKey`) is authorized for its
@@ -81,7 +87,8 @@ export function isAuthorizedKey(
     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/src/node/didWebResolver.ts

@@ -22,10 +22,7 @@ import {
   type DidDocument,
   type Secp256k1VerificationMethod,
 } from '@oxy.so/contracts';
-import type {
-  ResolvedVerificationMethods,
-  VerificationMethodResolver,
-} from '../identity/resolver';
+import type { ResolvedVerificationMethods, VerificationMethodResolver } from '../identity/resolver';
 import { type NodeFetch, readBoundedJson } from './httpFetch';
 import {
   DEFAULT_CLIENT_MAX_REDIRECTS,
@@ -95,9 +92,7 @@ function isSecp256k1Vm(
  */
 function collectCurrentPublicKeys(doc: DidDocument): string[] {
   const byId = new Map(
-    doc.verificationMethod
-      .filter(isSecp256k1Vm)
-      .map((vm) => [vm.id, vm.publicKeyHex] as const),
+    doc.verificationMethod.filter(isSecp256k1Vm).map((vm) => [vm.id, vm.publicKeyHex] as const),
   );
   const keys: string[] = [];
   for (const id of doc.assertionMethod) {

package/src/node/nodeApp.ts

@@ -261,7 +261,10 @@ export function createNodeApp(deps: NodeAppDependencies): NodeApp {
         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) {
       next(error);
@@ -288,7 +291,10 @@ export function createNodeApp(deps: NodeAppDependencies): NodeApp {
       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) {
@@ -305,80 +311,92 @@ export function createNodeApp(deps: NodeAppDependencies): NodeApp {
   });
 
   // ── Owner write: a single signed envelope ────────────────────────────────────
-  app.post(NODE_RECORDS_PATH, writeRateLimit, jsonParser, async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      const verification = await verifyNodeRecordEnvelope(req.body);
-      if (!verification.ok) {
-        res.status(400).json({ error: verification.reason });
-        return;
-      }
-      if (!ownerAuth.isOwnerKey(verification.envelope.publicKey)) {
-        res.status(403).json({ error: 'not_owner' });
-        return;
-      }
-      if (!isCollectionAllowed(config, verification.envelope.collection ?? '')) {
-        res.status(403).json({ error: 'foreign_collection' });
-        return;
-      }
-      const outcome = await store.append(subject, verification.envelope, verification.recordId);
-      if (!outcome.ok) {
-        res.status(appendStatus(outcome.reason)).json({ error: outcome.reason });
-        return;
-      }
-      res.status(201).json({ recordId: outcome.recordId, seq: outcome.seq });
-    } catch (error) {
-      next(error);
-    }
-  });
-
-  // ── Owner write: a batch push (verified + appended in order) ──────────────────
-  app.post(NODE_SYNC_PUSH_PATH, writeRateLimit, jsonParser, async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      const body: unknown = req.body;
-      const items =
-        typeof body === 'object' && body !== null && Array.isArray((body as { records?: unknown }).records)
-          ? (body as { records: unknown[] }).records
-          : null;
-      if (!items) {
-        res.status(400).json({ error: 'invalid_batch' });
-        return;
-      }
-      if (items.length > MAX_SYNC_BATCH) {
-        res.status(400).json({ error: 'batch_too_large' });
-        return;
-      }
-
-      const results: Array<
-        { ok: true; recordId: string; seq: number } | { ok: false; reason: string }
-      > = [];
-      for (const item of items) {
-        const verification = await verifyNodeRecordEnvelope(item);
+  app.post(
+    NODE_RECORDS_PATH,
+    writeRateLimit,
+    jsonParser,
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        const verification = await verifyNodeRecordEnvelope(req.body);
         if (!verification.ok) {
-          results.push({ ok: false, reason: verification.reason });
-          continue;
+          res.status(400).json({ error: verification.reason });
+          return;
         }
         if (!ownerAuth.isOwnerKey(verification.envelope.publicKey)) {
-          results.push({ ok: false, reason: 'not_owner' });
-          continue;
+          res.status(403).json({ error: 'not_owner' });
+          return;
         }
         if (!isCollectionAllowed(config, verification.envelope.collection ?? '')) {
-          results.push({ ok: false, reason: 'foreign_collection' });
-          continue;
+          res.status(403).json({ error: 'foreign_collection' });
+          return;
         }
         const outcome = await store.append(subject, verification.envelope, verification.recordId);
-        results.push(
-          outcome.ok
-            ? { ok: true, recordId: outcome.recordId, seq: outcome.seq }
-            : { ok: false, reason: outcome.reason },
-        );
+        if (!outcome.ok) {
+          res.status(appendStatus(outcome.reason)).json({ error: outcome.reason });
+          return;
+        }
+        res.status(201).json({ recordId: outcome.recordId, seq: outcome.seq });
+      } catch (error) {
+        next(error);
       }
+    },
+  );
 
-      const accepted = results.filter((result) => result.ok).length;
-      res.json({ accepted, results });
-    } catch (error) {
-      next(error);
-    }
-  });
+  // ── Owner write: a batch push (verified + appended in order) ──────────────────
+  app.post(
+    NODE_SYNC_PUSH_PATH,
+    writeRateLimit,
+    jsonParser,
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        const body: unknown = req.body;
+        const items =
+          typeof body === 'object' &&
+          body !== null &&
+          Array.isArray((body as { records?: unknown }).records)
+            ? (body as { records: unknown[] }).records
+            : null;
+        if (!items) {
+          res.status(400).json({ error: 'invalid_batch' });
+          return;
+        }
+        if (items.length > MAX_SYNC_BATCH) {
+          res.status(400).json({ error: 'batch_too_large' });
+          return;
+        }
+
+        const results: Array<
+          { ok: true; recordId: string; seq: number } | { ok: false; reason: string }
+        > = [];
+        for (const item of items) {
+          const verification = await verifyNodeRecordEnvelope(item);
+          if (!verification.ok) {
+            results.push({ ok: false, reason: verification.reason });
+            continue;
+          }
+          if (!ownerAuth.isOwnerKey(verification.envelope.publicKey)) {
+            results.push({ ok: false, reason: 'not_owner' });
+            continue;
+          }
+          if (!isCollectionAllowed(config, verification.envelope.collection ?? '')) {
+            results.push({ ok: false, reason: 'foreign_collection' });
+            continue;
+          }
+          const outcome = await store.append(subject, verification.envelope, verification.recordId);
+          results.push(
+            outcome.ok
+              ? { ok: true, recordId: outcome.recordId, seq: outcome.seq }
+              : { ok: false, reason: outcome.reason },
+          );
+        }
+
+        const accepted = results.filter((result) => result.ok).length;
+        res.json({ accepted, results });
+      } catch (error) {
+        next(error);
+      }
+    },
+  );
 
   // ── Serve a content-addressed blob ───────────────────────────────────────────
   app.get(`${NODE_BLOBS_PATH}/:hash`, async (req: Request, res: Response, next: NextFunction) => {

package/src/node/nodeClient.ts

@@ -13,12 +13,7 @@
  */
 
 import type { SignedRecordEnvelope } from '@oxy.so/contracts';
-import {
-  type NodeFetch,
-  type NodeFetchInit,
-  readBoundedBytes,
-  readBoundedJson,
-} from './httpFetch';
+import { type NodeFetch, type NodeFetchInit, readBoundedBytes, readBoundedJson } from './httpFetch';
 import {
   DEFAULT_CLIENT_MAX_REDIRECTS,
   DEFAULT_CLIENT_TIMEOUT_MS,
@@ -105,7 +100,11 @@ export interface NodeClientOptions {
 }
 
 function readError(body: unknown): string | undefined {
-  if (typeof body === 'object' && body !== null && typeof (body as { error?: unknown }).error === 'string') {
+  if (
+    typeof body === 'object' &&
+    body !== null &&
+    typeof (body as { error?: unknown }).error === 'string'
+  ) {
     return (body as { error: string }).error;
   }
   return undefined;
@@ -200,7 +199,10 @@ export class NodeClient {
       headRaw !== null &&
       typeof (headRaw as { seq?: unknown }).seq === 'number' &&
       typeof (headRaw as { headRecordId?: unknown }).headRecordId === 'string'
-        ? { seq: (headRaw as { seq: number }).seq, headRecordId: (headRaw as { headRecordId: string }).headRecordId }
+        ? {
+            seq: (headRaw as { seq: number }).seq,
+            headRecordId: (headRaw as { headRecordId: string }).headRecordId,
+          }
         : null;
     return { records, count: records.length, head };
   }
@@ -231,7 +233,10 @@ export class NodeClient {
     }
     const obj = body as { recordId?: unknown; seq?: unknown };
     if (typeof obj.recordId !== 'string' || typeof obj.seq !== 'number') {
-      throw new NodeClientError(`node ${NODE_RECORDS_PATH} returned a malformed write result`, res.status);
+      throw new NodeClientError(
+        `node ${NODE_RECORDS_PATH} returned a malformed write result`,
+        res.status,
+      );
     }
     return { recordId: obj.recordId, seq: obj.seq };
   }
@@ -241,9 +246,10 @@ export class NodeClient {
    * node's per-item results. Throws {@link NodeClientError} only on a non-2xx
    * batch-level failure (`invalid_batch` / `batch_too_large`).
    */
-  async pushRecords(
-    envelopes: SignedRecordEnvelope[],
-  ): Promise<{ accepted: number; results: Array<{ ok: boolean; recordId?: string; seq?: number; reason?: string }> }> {
+  async pushRecords(envelopes: SignedRecordEnvelope[]): Promise<{
+    accepted: number;
+    results: Array<{ ok: boolean; recordId?: string; seq?: number; reason?: string }>;
+  }> {
     const res = await this.fetch(
       `${this.baseUrl}${NODE_SYNC_PUSH_PATH}`,
       this.init({
@@ -272,14 +278,20 @@ export class NodeClient {
 
   /** Fetch a content-addressed blob. Returns `null` on a 404; throws on other non-2xx. */
   async getBlob(hash: string): Promise<Buffer | null> {
-    const res = await this.fetch(`${this.baseUrl}${NODE_BLOBS_PATH}/${encodeURIComponent(hash)}`, this.init({ method: 'GET' }));
+    const res = await this.fetch(
+      `${this.baseUrl}${NODE_BLOBS_PATH}/${encodeURIComponent(hash)}`,
+      this.init({ method: 'GET' }),
+    );
     if (res.status === 404) {
       res.destroy();
       return null;
     }
     if (res.status < 200 || res.status >= 300) {
       res.destroy();
-      throw new NodeClientError(`node ${NODE_BLOBS_PATH}/:hash responded HTTP ${res.status}`, res.status);
+      throw new NodeClientError(
+        `node ${NODE_BLOBS_PATH}/:hash responded HTTP ${res.status}`,
+        res.status,
+      );
     }
     return readBoundedBytes(res, this.blobMaxBytes);
   }
@@ -290,7 +302,11 @@ export class NodeClient {
    * passes the resulting `{ publicKey, signature, timestamp }`; the client sets
    * the owner-auth headers. Throws {@link NodeClientError} on a non-2xx.
    */
-  async putBlob(hash: string, bytes: Uint8Array, auth: NodeBlobPinAuth): Promise<NodeBlobPutResult> {
+  async putBlob(
+    hash: string,
+    bytes: Uint8Array,
+    auth: NodeBlobPinAuth,
+  ): Promise<NodeBlobPutResult> {
     const res = await this.fetch(
       `${this.baseUrl}${NODE_BLOBS_PATH}/${encodeURIComponent(hash)}`,
       this.init({
@@ -315,7 +331,10 @@ export class NodeClient {
     }
     const obj = body as { hash?: unknown; size?: unknown };
     if (typeof obj.hash !== 'string' || typeof obj.size !== 'number') {
-      throw new NodeClientError(`node ${NODE_BLOBS_PATH}/:hash returned a malformed pin result`, res.status);
+      throw new NodeClientError(
+        `node ${NODE_BLOBS_PATH}/:hash returned a malformed pin result`,
+        res.status,
+      );
     }
     return { hash: obj.hash, size: obj.size };
   }

package/src/platform/crypto.native.ts

@@ -244,7 +244,10 @@ function narrowSocialReceive(value: unknown): CommonsSocialReceiveSignature | nu
 }
 
 /** Run one native call; a rejection or an unexpected shape is `null`. */
-async function ask<T>(call: () => Promise<unknown>, narrow: (value: unknown) => T | null): Promise<T | null> {
+async function ask<T>(
+  call: () => Promise<unknown>,
+  narrow: (value: unknown) => T | null,
+): Promise<T | null> {
   try {
     return narrow(await call());
   } catch {
@@ -271,7 +274,11 @@ export function loadCommonsIdentityBridge(): Promise<CommonsIdentityBridge | nul
       return {
         describe: () => ask(() => m.describe(), narrowDescription),
         proveIdentity: (challenge: string) => ask(() => m.proveIdentity(challenge), narrowProof),
-        deriveScopedSeed: (info: string) => ask(() => m.deriveScopedSeed(info), (v) => hexField(v, 64)),
+        deriveScopedSeed: (info: string) =>
+          ask(
+            () => m.deriveScopedSeed(info),
+            (v) => hexField(v, 64),
+          ),
         signSocialReceive: (index: number, digest: string) =>
           ask(() => m.signSocialReceive(index, digest), narrowSocialReceive),
       } satisfies CommonsIdentityBridge;

package/src/platform/platform.ts

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

package/src/secp256k1.ts

@@ -7,7 +7,7 @@
  * 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}$/;
@@ -26,9 +26,9 @@ export interface Secp256k1SignatureOptions {
 }
 
 function bytesToHex(bytes: Uint8Array): string {
-  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;
 }
@@ -51,20 +51,18 @@ function hexToBytes(value: string, label: string): Uint8Array {
  */
 export function normalizeSecp256k1PrivateKey(privateKeyHex: string): string {
   if (
-    typeof privateKeyHex !== "string" ||
+    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;
 }
@@ -80,36 +78,28 @@ export function isValidSecp256k1PrivateKey(privateKeyHex: string): boolean {
 }
 
 function parsePrivateKey(privateKeyHex: string): Uint8Array {
-  return hexToBytes(
-    normalizeSecp256k1PrivateKey(privateKeyHex),
-    "secp256k1 private key",
-  );
+  return hexToBytes(normalizeSecp256k1PrivateKey(privateKeyHex), 'secp256k1 private key');
 }
 
 function parsePublicKey(publicKeyHex: string): Uint8Array {
   if (
-    typeof publicKeyHex !== "string" ||
-    (!COMPRESSED_PUBLIC_KEY.test(publicKeyHex) &&
-      !UNCOMPRESSED_PUBLIC_KEY.test(publicKeyHex))
+    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",
-    );
+    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: string): Uint8Array {
-  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. */
@@ -132,20 +122,12 @@ export function generateSecp256k1KeyPair(): Secp256k1KeyPair {
 }
 
 /** Derive a compressed or uncompressed SEC1 public key from a private scalar. */
-export function deriveSecp256k1PublicKey(
-  privateKeyHex: string,
-  compressed = false,
-): string {
-  return bytesToHex(
-    secp256k1.getPublicKey(parsePrivateKey(privateKeyHex), compressed),
-  );
+export function deriveSecp256k1PublicKey(privateKeyHex: string, compressed = false): string {
+  return bytesToHex(secp256k1.getPublicKey(parsePrivateKey(privateKeyHex), compressed));
 }
 
 /** Parse and re-encode a public key in canonical lowercase SEC1 form. */
-export function normalizeSecp256k1PublicKey(
-  publicKeyHex: string,
-  compressed = false,
-): string {
+export function normalizeSecp256k1PublicKey(publicKeyHex: string, compressed = false): string {
   const point = secp256k1.Point.fromBytes(parsePublicKey(publicKeyHex));
   return point.toHex(compressed);
 }
@@ -162,14 +144,10 @@ export function signSecp256k1Digest(
   digestHex: string,
   options: Secp256k1SignatureOptions = {},
 ): string {
-  const signature = secp256k1.sign(
-    parseDigest(digestHex),
-    parsePrivateKey(privateKeyHex),
-    {
-      lowS: options.lowS ?? false,
-    },
-  );
-  return signature.toHex("der");
+  const signature = secp256k1.sign(parseDigest(digestHex), parsePrivateKey(privateKeyHex), {
+    lowS: options.lowS ?? false,
+  });
+  return signature.toHex('der');
 }
 
 /** Verify a DER-encoded ECDSA signature, accepting historical high-S signatures. */
@@ -180,12 +158,12 @@ export function verifySecp256k1Digest(
 ): boolean {
   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,
   });
 }
@@ -197,24 +175,21 @@ export function verifySecp256k1Digest(
  * Throws, as BIP32 requires, when the tweak is not below the curve order or
  * the sum is zero: that child is invalid and the caller must not use it.
  */
-export function tweakAddSecp256k1PrivateKey(
-  privateKeyHex: string,
-  tweakHex: string,
-): string {
+export function tweakAddSecp256k1PrivateKey(privateKeyHex: string, tweakHex: string): string {
   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. */
@@ -228,7 +203,7 @@ export function deriveSecp256k1SharedSecret(
     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);
 }