@oxy.so/protocol 1.2.2 → 1.3.0

package/src/__tests__/optionalNativePeers.test.ts

@@ -26,9 +26,7 @@ import { dirname, join, resolve } from 'node:path';
 const SRC_DIR = resolve(__dirname, '..');
 const ROOT_ENTRY = join(SRC_DIR, 'index.ts');
 
-const packageJson = JSON.parse(
-  readFileSync(resolve(SRC_DIR, '..', 'package.json'), 'utf8'),
-) as {
+const packageJson = JSON.parse(readFileSync(resolve(SRC_DIR, '..', 'package.json'), 'utf8')) as {
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 };
 
@@ -218,9 +216,13 @@ describe('crypto.native optional-peer degradation', () => {
       });
       jest.doMock('expo-crypto', () => fakeCrypto, { virtual: true });
       jest.doMock('expo-secure-store', () => fakeSecureStore, { virtual: true });
-      jest.doMock('@react-native-async-storage/async-storage', () => ({ default: fakeAsyncStorage }), {
-        virtual: true,
-      });
+      jest.doMock(
+        '@react-native-async-storage/async-storage',
+        () => ({ default: fakeAsyncStorage }),
+        {
+          virtual: true,
+        },
+      );
 
       const mod = require(MODULE_PATH) as typeof import('../platform/crypto.native');
 

package/src/__tests__/rateLimit.test.ts

@@ -209,7 +209,8 @@ describe('createRateLimiter', () => {
       await jest.isolateModulesAsync(async () => {
         const reloaded = await import('../node/rateLimit');
         afterRestart = reloaded.clientRateLimitKey({ ip: ADDRESS } as Request);
-        stableAfterRestart = reloaded.clientRateLimitKey({ ip: ADDRESS } as Request) === afterRestart;
+        stableAfterRestart =
+          reloaded.clientRateLimitKey({ ip: ADDRESS } as Request) === afterRestart;
       });
 
       expect(afterRestart).not.toBe(before);

package/src/__tests__/registrationPow.test.ts

@@ -3,70 +3,68 @@ import {
   meetsRegistrationPowDifficulty,
   registrationPowMessage,
   REGISTRATION_POW_DIFFICULTY_BITS,
-} from "../auth/registrationPow";
+} from '../auth/registrationPow';
 
-describe("registrationPowMessage", () => {
-  test("binds publicKey, timestamp and nonce, distinct from the registration signature message", () => {
-    expect(registrationPowMessage("pk", 1700000000000, "42")).toBe(
-      "oxy:register-pow:pk:1700000000000:42",
+describe('registrationPowMessage', () => {
+  test('binds publicKey, timestamp and nonce, distinct from the registration signature message', () => {
+    expect(registrationPowMessage('pk', 1700000000000, '42')).toBe(
+      'oxy:register-pow:pk:1700000000000:42',
     );
   });
 
-  test("a different nonce is a different message", () => {
-    expect(registrationPowMessage("pk", 1, "a")).not.toBe(
-      registrationPowMessage("pk", 1, "b"),
-    );
+  test('a different nonce is a different message', () => {
+    expect(registrationPowMessage('pk', 1, 'a')).not.toBe(registrationPowMessage('pk', 1, 'b'));
   });
 });
 
-describe("countLeadingZeroBits", () => {
+describe('countLeadingZeroBits', () => {
   test.each([
-    ["", 0],
-    ["f", 0],
-    ["8000", 0],
-    ["0", 4],
-    ["00", 8],
-    ["01", 7],
-    ["0f", 4],
-    ["1f", 3],
-    ["2f", 2],
-    ["4f", 1],
-    ["0000f", 16],
+    ['', 0],
+    ['f', 0],
+    ['8000', 0],
+    ['0', 4],
+    ['00', 8],
+    ['01', 7],
+    ['0f', 4],
+    ['1f', 3],
+    ['2f', 2],
+    ['4f', 1],
+    ['0000f', 16],
     // Case-insensitive: the digest producers this compares against are
     // lowercase, but the counter must not silently under-count an uppercase one.
-    ["00F", 8],
-  ])("counts %s as %i leading zero bits", (hex, expected) => {
+    ['00F', 8],
+  ])('counts %s as %i leading zero bits', (hex, expected) => {
     expect(countLeadingZeroBits(hex)).toBe(expected);
   });
 
-  test("stops at the first non-zero nibble rather than scanning the whole digest", () => {
-    expect(countLeadingZeroBits(`00f${"0".repeat(60)}`)).toBe(8);
+  test('stops at the first non-zero nibble rather than scanning the whole digest', () => {
+    expect(countLeadingZeroBits(`00f${'0'.repeat(60)}`)).toBe(8);
   });
 
-  test("a non-hex character ends the count instead of throwing", () => {
-    expect(countLeadingZeroBits("0z")).toBe(4);
-    expect(() => countLeadingZeroBits("not-hex-at-all")).not.toThrow();
+  test('a non-hex character ends the count instead of throwing', () => {
+    expect(countLeadingZeroBits('0z')).toBe(4);
+    expect(() => countLeadingZeroBits('not-hex-at-all')).not.toThrow();
   });
 });
 
-describe("meetsRegistrationPowDifficulty", () => {
-  test("passes a digest that clears the bound", () => {
-    expect(meetsRegistrationPowDifficulty("00f0", 8)).toBe(true);
-    expect(meetsRegistrationPowDifficulty("00f0", 9)).toBe(false);
+describe('meetsRegistrationPowDifficulty', () => {
+  test('passes a digest that clears the bound', () => {
+    expect(meetsRegistrationPowDifficulty('00f0', 8)).toBe(true);
+    expect(meetsRegistrationPowDifficulty('00f0', 9)).toBe(false);
   });
 
-  test("an exact match at the bound passes", () => {
-    expect(meetsRegistrationPowDifficulty("00f0", 8)).toBe(true);
+  test('an exact match at the bound passes', () => {
+    expect(meetsRegistrationPowDifficulty('00f0', 8)).toBe(true);
   });
 
-  test("the exported difficulty constant is a defensible, positive bound", () => {
+  test('the exported difficulty constant is a defensible, positive bound', () => {
     // Pinned as a regression check on the constant itself: a change here is a
     // deliberate retune, not an accidental one, and shows up in review.
     expect(REGISTRATION_POW_DIFFICULTY_BITS).toBe(16);
-    expect(meetsRegistrationPowDifficulty("0".repeat(64), REGISTRATION_POW_DIFFICULTY_BITS)).toBe(
+    expect(meetsRegistrationPowDifficulty('0'.repeat(64), REGISTRATION_POW_DIFFICULTY_BITS)).toBe(
       true,
     );
-    expect(meetsRegistrationPowDifficulty("f".repeat(64), REGISTRATION_POW_DIFFICULTY_BITS)).toBe(
+    expect(meetsRegistrationPowDifficulty('f'.repeat(64), REGISTRATION_POW_DIFFICULTY_BITS)).toBe(
       false,
     );
   });

package/src/__tests__/secp256k1.test.ts

@@ -8,111 +8,82 @@ import {
   normalizeSecp256k1PublicKey,
   signSecp256k1Digest,
   verifySecp256k1Digest,
-} from "../secp256k1";
+} from '../secp256k1';
 
-const PRIVATE_KEY_ONE = `${"0".repeat(63)}1`;
-const PRIVATE_KEY_TWO = `${"0".repeat(63)}2`;
-const DIGEST_ONE = `${"0".repeat(63)}1`;
+const PRIVATE_KEY_ONE = `${'0'.repeat(63)}1`;
+const PRIVATE_KEY_TWO = `${'0'.repeat(63)}2`;
+const DIGEST_ONE = `${'0'.repeat(63)}1`;
 
 const PUBLIC_KEY_ONE =
-  "0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" +
-  "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8";
+  '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+  '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8';
 const COMPRESSED_PUBLIC_KEY_ONE =
-  "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
+  '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
 const PUBLIC_KEY_TWO =
-  "04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5" +
-  "1ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a";
+  '04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5' +
+  '1ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a';
 
 // Exact DER output produced by elliptic 6.6.1 for this RFC 6979 vector.
 const HISTORICAL_HIGH_S_SIGNATURE =
-  "304502206673ffad2147741f04772b6f921f0ba6af0c1e77fc439e65c36dedf4092e8898" +
-  "022100b3e568e9ad1f52577fedf107fda18f5ebb8e5c220badf23532bf6fbcc67fb4b8";
+  '304502206673ffad2147741f04772b6f921f0ba6af0c1e77fc439e65c36dedf4092e8898' +
+  '022100b3e568e9ad1f52577fedf107fda18f5ebb8e5c220badf23532bf6fbcc67fb4b8';
 const LOW_S_SIGNATURE =
-  "304402206673ffad2147741f04772b6f921f0ba6af0c1e77fc439e65c36dedf4092e8898" +
-  "02204c1a971652e0ada880120ef8025e709fff2080c4a39aae068d12eed009b68c89";
+  '304402206673ffad2147741f04772b6f921f0ba6af0c1e77fc439e65c36dedf4092e8898' +
+  '02204c1a971652e0ada880120ef8025e709fff2080c4a39aae068d12eed009b68c89';
 
-describe("secp256k1 primitives", () => {
-  test("preserves the canonical private/public key formats", () => {
-    expect(normalizeSecp256k1PrivateKey("1")).toBe(PRIVATE_KEY_ONE);
+describe('secp256k1 primitives', () => {
+  test('preserves the canonical private/public key formats', () => {
+    expect(normalizeSecp256k1PrivateKey('1')).toBe(PRIVATE_KEY_ONE);
     expect(deriveSecp256k1PublicKey(PRIVATE_KEY_ONE)).toBe(PUBLIC_KEY_ONE);
-    expect(deriveSecp256k1PublicKey(PRIVATE_KEY_ONE, true)).toBe(
-      COMPRESSED_PUBLIC_KEY_ONE,
-    );
-    expect(normalizeSecp256k1PublicKey(COMPRESSED_PUBLIC_KEY_ONE)).toBe(
-      PUBLIC_KEY_ONE,
-    );
-    expect(normalizeSecp256k1PublicKey(PUBLIC_KEY_ONE, true)).toBe(
-      COMPRESSED_PUBLIC_KEY_ONE,
-    );
+    expect(deriveSecp256k1PublicKey(PRIVATE_KEY_ONE, true)).toBe(COMPRESSED_PUBLIC_KEY_ONE);
+    expect(normalizeSecp256k1PublicKey(COMPRESSED_PUBLIC_KEY_ONE)).toBe(PUBLIC_KEY_ONE);
+    expect(normalizeSecp256k1PublicKey(PUBLIC_KEY_ONE, true)).toBe(COMPRESSED_PUBLIC_KEY_ONE);
   });
 
-  test("matches the historical deterministic DER wire format", () => {
+  test('matches the historical deterministic DER wire format', () => {
     const signature = signSecp256k1Digest(PRIVATE_KEY_ONE, DIGEST_ONE);
     expect(signature).toBe(HISTORICAL_HIGH_S_SIGNATURE);
-    expect(verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, signature)).toBe(
-      true,
-    );
-    expect(
-      verifySecp256k1Digest(COMPRESSED_PUBLIC_KEY_ONE, DIGEST_ONE, signature),
-    ).toBe(true);
+    expect(verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, signature)).toBe(true);
+    expect(verifySecp256k1Digest(COMPRESSED_PUBLIC_KEY_ONE, DIGEST_ONE, signature)).toBe(true);
   });
 
-  test("supports explicit low-S signatures while accepting both historical forms", () => {
+  test('supports explicit low-S signatures while accepting both historical forms', () => {
     const signature = signSecp256k1Digest(PRIVATE_KEY_ONE, DIGEST_ONE, {
       lowS: true,
     });
     expect(signature).toBe(LOW_S_SIGNATURE);
-    expect(verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, signature)).toBe(
+    expect(verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, signature)).toBe(true);
+    expect(verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, HISTORICAL_HIGH_S_SIGNATURE)).toBe(
       true,
     );
-    expect(
-      verifySecp256k1Digest(
-        PUBLIC_KEY_ONE,
-        DIGEST_ONE,
-        HISTORICAL_HIGH_S_SIGNATURE,
-      ),
-    ).toBe(true);
   });
 
-  test("derives the fixed-width ECDH x-coordinate symmetrically", () => {
-    const expected =
-      "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5";
-    const oneToTwo = deriveSecp256k1SharedSecret(
-      PRIVATE_KEY_ONE,
-      PUBLIC_KEY_TWO,
-    );
-    const twoToOne = deriveSecp256k1SharedSecret(
-      PRIVATE_KEY_TWO,
-      PUBLIC_KEY_ONE,
-    );
+  test('derives the fixed-width ECDH x-coordinate symmetrically', () => {
+    const expected = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
+    const oneToTwo = deriveSecp256k1SharedSecret(PRIVATE_KEY_ONE, PUBLIC_KEY_TWO);
+    const twoToOne = deriveSecp256k1SharedSecret(PRIVATE_KEY_TWO, PUBLIC_KEY_ONE);
 
-    expect(Buffer.from(oneToTwo).toString("hex")).toBe(expected);
+    expect(Buffer.from(oneToTwo).toString('hex')).toBe(expected);
     expect(oneToTwo).toEqual(twoToOne);
     expect(oneToTwo).toHaveLength(32);
   });
 
-  test("generates canonical key pairs that round-trip", () => {
+  test('generates canonical key pairs that round-trip', () => {
     const keyPair = generateSecp256k1KeyPair();
     expect(keyPair.privateKey).toMatch(/^[0-9a-f]{64}$/);
     expect(keyPair.publicKey).toMatch(/^04[0-9a-f]{128}$/);
-    expect(deriveSecp256k1PublicKey(keyPair.privateKey)).toBe(
-      keyPair.publicKey,
-    );
+    expect(deriveSecp256k1PublicKey(keyPair.privateKey)).toBe(keyPair.publicKey);
   });
 
-  test("strictly rejects malformed scalars, points, digests, and DER", () => {
-    expect(isValidSecp256k1PrivateKey("0")).toBe(false);
-    expect(isValidSecp256k1PrivateKey("zz")).toBe(false);
-    expect(isValidSecp256k1PrivateKey("f".repeat(66))).toBe(false);
-    expect(isValidSecp256k1PublicKey(`04${"0".repeat(128)}`)).toBe(false);
-    expect(isValidSecp256k1PublicKey(`05${PUBLIC_KEY_ONE.slice(2)}`)).toBe(
-      false,
-    );
-    expect(() => signSecp256k1Digest(PRIVATE_KEY_ONE, "00")).toThrow(
-      "digest must be exactly 32 bytes",
+  test('strictly rejects malformed scalars, points, digests, and DER', () => {
+    expect(isValidSecp256k1PrivateKey('0')).toBe(false);
+    expect(isValidSecp256k1PrivateKey('zz')).toBe(false);
+    expect(isValidSecp256k1PrivateKey('f'.repeat(66))).toBe(false);
+    expect(isValidSecp256k1PublicKey(`04${'0'.repeat(128)}`)).toBe(false);
+    expect(isValidSecp256k1PublicKey(`05${PUBLIC_KEY_ONE.slice(2)}`)).toBe(false);
+    expect(() => signSecp256k1Digest(PRIVATE_KEY_ONE, '00')).toThrow(
+      'digest must be exactly 32 bytes',
     );
-    expect(() =>
-      verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, "00"),
-    ).toThrow();
+    expect(() => verifySecp256k1Digest(PUBLIC_KEY_ONE, DIGEST_ONE, '00')).toThrow();
   });
 });

package/src/__tests__/transparency.test.ts

@@ -216,7 +216,10 @@ describe('verifyInclusionProof', () => {
     const entries = heads(5);
     const tree = await buildTransparencyTreeFromHeads(entries);
     const proof = inclusionProof(tree, 2);
-    const tamperedLeaf = await transparencyLeafHash({ ...entries[2], headRecordId: 'f'.repeat(64) });
+    const tamperedLeaf = await transparencyLeafHash({
+      ...entries[2],
+      headRecordId: 'f'.repeat(64),
+    });
     await expect(
       verifyInclusionProof({ leaf: tamperedLeaf, index: 2, treeSize: 5, proof, root: tree.root }),
     ).resolves.toBe(false);

package/src/auth/registrationPow.ts

@@ -89,7 +89,11 @@ const NIBBLE_LEADING_ZERO_BITS: Readonly<Record<string, number>> = {
  * vice versa — the two are unrelated preimages even for the same
  * `publicKey`/`timestamp` pair.
  */
-export function registrationPowMessage(publicKey: string, timestamp: number, nonce: string): string {
+export function registrationPowMessage(
+  publicKey: string,
+  timestamp: number,
+  nonce: string,
+): string {
   return `oxy:register-pow:${publicKey}:${timestamp}:${nonce}`;
 }
 

package/src/chain/engine.ts

@@ -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 type { SignedRecordEnvelope } from '@oxy.so/contracts';

package/src/chain/recordStore.ts

@@ -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/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) {