@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/sig/proof.test.mjs

@@ -1,18 +1,26 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import "../std__assert-B2NnY9bq.mjs";
-import { n as assertGreaterOrEqual, r as assertFalse, t as assertRejects } from "../assert_rejects-EgstcQy5.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-Q9KTBnrf.mjs";
-import { t as assert } from "../assert-CJ1KXcvv.mjs";
-import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-Dbyd7bhl.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-URuqsICz.mjs";
-import { a as verifyProof, i as verifyObject, n as hasProofLike, r as signObject, t as createProof } from "../proof-B4ngoaNQ.mjs";
-import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place } from "@fedify/vocab";
+import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { a as verificationObservation } from "../verification-Dpfcw8ml.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
+import { a as signObject, c as verifyPortableObjectProof, d as verifyProof, i as hasProofLike, o as verifyMapLocalProof, r as createProof, s as verifyObject } from "../proof-Dxy6ByqI.mjs";
+import { f as verifyRequest } from "../http-siciWkmx.mjs";
+import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-DBoYbvYW.mjs";
+import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place, Translation } from "@fedify/vocab";
+import { decodeMultibase, encodeMultibase, exportDidKey, exportMultibaseKey, formatIri, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
-import { decodeMultibase, exportDidKey, exportMultibaseKey, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";
 import { decodeHex } from "byte-encodings/hex";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+import serialize from "json-canon";
 //#region src/sig/proof.test.ts
 const fep8b32TestVectorPrivateKey = await crypto.subtle.importKey("jwk", {
 	"kty": "OKP",
@@ -23,6 +31,53 @@ const fep8b32TestVectorPrivateKey = await crypto.subtle.importKey("jwk", {
 	ext: true
 }, "Ed25519", true, ["sign"]);
 const fep8b32TestVectorKeyId = new URL("https://server.example/users/alice#ed25519-key");
+const portableDid = await exportDidKey(ed25519PublicKey.publicKey);
+const portableDidMethod = portableDid.substring(8);
+const portableKeyId = new URL(`${portableDid}#${portableDidMethod}`);
+const portableContext = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+const portableActorContext = [...portableContext, "https://w3id.org/fep/ef61"];
+const portableProofCreated = "2023-02-24T23:36:38Z";
+async function signPortableJsonLd(document, { privateKey = ed25519PrivateKey, verificationMethod = portableKeyId, proofOptions = {} } = {}) {
+	const proofConfig = {
+		"@context": document["@context"],
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod: verificationMethod.href,
+		proofPurpose: "assertionMethod",
+		created: portableProofCreated,
+		...proofOptions
+	};
+	const encoder = new TextEncoder();
+	const proofDigest = await crypto.subtle.digest("SHA-256", encoder.encode(serialize(proofConfig)));
+	const messageDigest = await crypto.subtle.digest("SHA-256", encoder.encode(serialize(document)));
+	const digest = new Uint8Array(proofDigest.byteLength + messageDigest.byteLength);
+	digest.set(new Uint8Array(proofDigest), 0);
+	digest.set(new Uint8Array(messageDigest), proofDigest.byteLength);
+	const signature = await crypto.subtle.sign("Ed25519", privateKey, digest);
+	return {
+		...document,
+		proof: {
+			...proofConfig,
+			proofValue: new TextDecoder().decode(encodeMultibase("base58btc", new Uint8Array(signature)))
+		}
+	};
+}
+async function parsePortableProof(document) {
+	const proof = document.proof;
+	assert(typeof proof === "object" && proof != null && !Array.isArray(proof));
+	return await DataIntegrityProof.fromJsonLd({
+		"@context": document["@context"],
+		...proof
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+}
+async function assertPortableProofVerified(document, options) {
+	const key = await verifyProof(document, await parsePortableProof(document), options);
+	assert(key != null);
+	assertEquals(key.id, portableKeyId);
+}
 const fep8b32TestVectorActivity = new Create({
 	id: new URL("https://server.example/activities/1"),
 	actor: new URL("https://server.example/users/alice"),
@@ -326,6 +381,202 @@ test("verifyProof()", async () => {
 	}), null);
 	assertFalse(contextLoaderCalls.includes("https://attacker.example/ctx"));
 });
+test("verifyProof() authenticates the complete proof configuration", async (t) => {
+	const jsonLd = {
+		"@context": portableContext,
+		id: "https://example.com/activities/complete-proof-options",
+		type: "Create",
+		actor: "https://example.com/users/alice",
+		object: {
+			type: "Note",
+			content: "Every proof option is authenticated."
+		}
+	};
+	const options = {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	await t.step("rejects an expires option added after signing", async () => {
+		const signed = await signPortableJsonLd(jsonLd);
+		const tampered = {
+			...signed,
+			proof: {
+				...signed.proof,
+				expires: "3000-01-01T00:00:00Z"
+			}
+		};
+		assertEquals(await verifyProof(tampered, await parsePortableProof(tampered), options), null);
+	});
+	await t.step("accepts an authenticated future expiration", async () => {
+		await assertPortableProofVerified(await signPortableJsonLd(jsonLd, { proofOptions: { expires: "3000-01-01T00:00:00Z" } }), options);
+	});
+	await t.step("rejects an authenticated expired proof", async () => {
+		const signed = await signPortableJsonLd(jsonLd, { proofOptions: { expires: "2000-01-01T00:00:00Z" } });
+		assertEquals(await verifyProof(signed, await parsePortableProof(signed), options), null);
+	});
+	await t.step("authenticates domain, challenge, and nonce", async () => {
+		const signed = await signPortableJsonLd(jsonLd, { proofOptions: {
+			domain: ["social.example", "https://social.example"],
+			challenge: "challenge-123",
+			nonce: "nonce-456"
+		} });
+		const proof = await parsePortableProof(signed);
+		const matchingKey = await verifyProof(signed, proof, {
+			...options,
+			domain: ["https://social.example", "social.example"],
+			challenge: "challenge-123"
+		});
+		assert(matchingKey != null);
+		assertEquals(matchingKey.id, portableKeyId);
+		assertEquals(await verifyProof(signed, proof, {
+			...options,
+			domain: ["social.example"],
+			challenge: "challenge-123"
+		}), null);
+		assertEquals(await verifyProof(signed, proof, {
+			...options,
+			domain: ["https://social.example", "social.example"],
+			challenge: "wrong-challenge"
+		}), null);
+		for (const [property, value] of [
+			["domain", ["other.example"]],
+			["challenge", "tampered-challenge"],
+			["nonce", "tampered-nonce"]
+		]) {
+			const tampered = {
+				...signed,
+				proof: {
+					...signed.proof,
+					[property]: value
+				}
+			};
+			assertEquals(await verifyProof(tampered, await parsePortableProof(tampered), options), null);
+		}
+	});
+	await t.step("requires requested domain and challenge options", async () => {
+		const signed = await signPortableJsonLd(jsonLd);
+		const proof = await parsePortableProof(signed);
+		assertEquals(await verifyProof(signed, proof, {
+			...options,
+			domain: "social.example"
+		}), null);
+		assertEquals(await verifyProof(signed, proof, {
+			...options,
+			challenge: "challenge-123"
+		}), null);
+	});
+	await t.step("rejects malformed proof options", async () => {
+		for (const proofOptions of [
+			{ expires: "not-a-date" },
+			{ domain: ["social.example", 42] },
+			{ challenge: 42 },
+			{ nonce: { value: "not-a-string" } },
+			{ nonce: [
+				"not",
+				"a",
+				"string"
+			] },
+			{ previousProof: ["urn:uuid:proof-1", 42] }
+		]) {
+			const signed = await signPortableJsonLd(jsonLd, { proofOptions });
+			assertEquals(await verifyProof(signed, await parsePortableProof(signed), options), null);
+		}
+	});
+	await t.step("authenticates aliased and extension options", async () => {
+		const signed = await signPortableJsonLd({
+			...jsonLd,
+			"@context": [...portableContext, {
+				validUntil: {
+					"@id": "https://w3id.org/security#expiration",
+					"@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+				},
+				extensionOption: "https://example.com/security#extensionOption"
+			}]
+		}, { proofOptions: {
+			validUntil: "3000-01-01T00:00:00Z",
+			extensionOption: { nested: ["one", "two"] }
+		} });
+		await assertPortableProofVerified(signed, options);
+		for (const [property, value] of [["validUntil", "2999-01-01T00:00:00Z"], ["extensionOption", { nested: ["one", "changed"] }]]) {
+			const tampered = {
+				...signed,
+				proof: {
+					...signed.proof,
+					[property]: value
+				}
+			};
+			assertEquals(await verifyProof(tampered, await parsePortableProof(tampered), options), null);
+		}
+	});
+	await t.step("distinguishes equivalent and ambiguous raw proof configurations", async () => {
+		const signed = await signPortableJsonLd(jsonLd);
+		const proof = signed.proof;
+		const parsed = await parsePortableProof(signed);
+		assert(await verifyProof({
+			...signed,
+			proof: [proof, structuredClone(proof)]
+		}, parsed, options) != null);
+		const inheritedContextProof = structuredClone(proof);
+		delete inheritedContextProof["@context"];
+		assert(await verifyProof({
+			...signed,
+			proof: [proof, inheritedContextProof]
+		}, parsed, options) != null);
+		assertEquals(await verifyProof({
+			...signed,
+			proof: [proof, {
+				...structuredClone(proof),
+				expires: "3000-01-01T00:00:00Z"
+			}]
+		}, parsed, options), null);
+	});
+	await t.step("accepts literal proof fields with an unresolved extra context", async () => {
+		const signed = await signPortableJsonLd({
+			...jsonLd,
+			"@context": [...portableContext, "https://context.example/unrelated"]
+		});
+		const rawProof = signed.proof;
+		const key = await verifyProof(signed, new DataIntegrityProof({
+			cryptosuite: "eddsa-jcs-2022",
+			verificationMethod: portableKeyId,
+			proofPurpose: "assertionMethod",
+			proofValue: decodeMultibase(rawProof.proofValue),
+			created: Temporal.Instant.from(portableProofCreated)
+		}), options);
+		assert(key != null);
+		assertEquals(key.id, portableKeyId);
+	});
+	await t.step("rejects aliases whose proof context cannot be resolved safely", async () => {
+		const contextUrl = "https://context.example/proof-options";
+		const signed = await signPortableJsonLd({
+			...jsonLd,
+			"@context": [...portableContext, contextUrl]
+		}, { proofOptions: { validUntil: "2000-01-01T00:00:00Z" } });
+		const rawProof = signed.proof;
+		const proof = new DataIntegrityProof({
+			cryptosuite: "eddsa-jcs-2022",
+			verificationMethod: portableKeyId,
+			proofPurpose: "assertionMethod",
+			proofValue: decodeMultibase(rawProof.proofValue),
+			created: Temporal.Instant.from(portableProofCreated)
+		});
+		const contextLoader = async (url) => {
+			if (url !== contextUrl) return await mockDocumentLoader(url);
+			return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { validUntil: {
+					"@id": "https://w3id.org/security#expiration",
+					"@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+				} } }
+			};
+		};
+		assertEquals(await verifyProof(signed, proof, {
+			...options,
+			contextLoader
+		}), null);
+	});
+});
 test("verifyProof() resolves did:key verification methods locally", async () => {
 	const multibaseKey = (await exportDidKey(ed25519PublicKey.publicKey)).slice(8);
 	const did = `did:key:${multibaseKey}`;
@@ -508,12 +759,13 @@ test("verifyProof() records verification duration metric", async (t) => {
 	});
 	await t.step("verifyObject() wrapper emits one measurement per inner verifyProof()", async () => {
 		const [meterProvider, recorder] = createTestMeterProvider();
+		const { "@context": _proofContext, ...embeddedProof } = await proof.toJsonLd({
+			format: "compact",
+			contextLoader: mockDocumentLoader
+		});
 		assert(await verifyObject(Create, {
 			...jsonLd,
-			proof: await proof.toJsonLd({
-				format: "compact",
-				contextLoader: mockDocumentLoader
-			})
+			proof: embeddedProof
 		}, {
 			documentLoader: mockDocumentLoader,
 			contextLoader: mockDocumentLoader,
@@ -547,6 +799,1012 @@ test("verifyProof() records verification duration metric", async (t) => {
 		assertFalse("object_integrity_proofs.cryptosuite" in measurements[0].attributes);
 	});
 });
+test("proof verification processes raw declaration contexts only for observers", async (t) => {
+	const options = {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	const proofUrl = `ap://did:key:${portableDidMethod}/proofs/diagnostics`;
+	const signed = await signPortableJsonLd({
+		"@context": portableContext,
+		id: `ap://did:key:${portableDidMethod}/objects/diagnostics`,
+		type: "Note",
+		attributedTo: `ap://did:key:${portableDidMethod}/actor`,
+		content: "Observed proof"
+	}, { proofOptions: { id: proofUrl } });
+	const rawProof = signed.proof;
+	const proof = await DataIntegrityProof.fromJsonLd(rawProof, options);
+	const referenced = { ...signed };
+	delete referenced.proof;
+	referenced["https://w3id.org/security#proof"] = { "@graph": [{ "@id": proofUrl }] };
+	const cases = [
+		{
+			name: "object",
+			verify: async (options) => await verifyObject(Note, structuredClone(signed), options) != null
+		},
+		{
+			name: "portable",
+			verify: async (options) => (await verifyPortableObjectProof(structuredClone(signed), options)).verified
+		},
+		{
+			name: "map-local",
+			verify: async (options) => await verifyMapLocalProof(structuredClone(signed), options) != null
+		},
+		{
+			name: "proof",
+			verify: async (options) => await verifyProof(structuredClone(signed), proof, options) != null
+		},
+		{
+			name: "remote proof",
+			verify: async (options) => await verifyObject(Note, structuredClone(referenced), {
+				...options,
+				documentLoader: (url) => Promise.resolve({
+					contextUrl: null,
+					documentUrl: url,
+					document: structuredClone(rawProof)
+				})
+			}) != null
+		}
+	];
+	for (const { name, verify } of cases) await t.step(name, async () => {
+		const original = jsonld.processContext;
+		let calls = 0;
+		jsonld.processContext = (...args) => {
+			calls++;
+			return original(...args);
+		};
+		try {
+			assert(await verify(options));
+			const unobservedCalls = calls;
+			calls = 0;
+			assert(await verify({
+				...options,
+				[verificationObservation]: {
+					attempts: [],
+					attempt: { checks: [] }
+				}
+			}));
+			assert(calls > unobservedCalls, "Raw declaration processing should be absent from unobserved verification");
+		} finally {
+			jsonld.processContext = original;
+		}
+	});
+});
+test("verifyPortableObjectProof()", async (t) => {
+	const options = {
+		documentLoader() {
+			throw new TypeError("did:key must not use the document loader");
+		},
+		contextLoader: mockDocumentLoader
+	};
+	const objectId = `ap://did:key:${portableDidMethod}/objects/1`;
+	const unsignedObject = {
+		"@context": portableContext,
+		id: objectId,
+		type: "Note",
+		attributedTo: `ap://did:key:${portableDidMethod}/actor`,
+		content: "Portable note"
+	};
+	await t.step("verifies a portable object with a matching DID proof", async () => {
+		const result = await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject), options);
+		assert(result.verified);
+		assertEquals(result.keys.length, 1);
+		assertEquals(result.keys[0].id, portableKeyId);
+	});
+	await t.step("rejects unauthenticated and expired proof options", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const tamperedResult = await verifyPortableObjectProof({
+			...signed,
+			proof: {
+				...signed.proof,
+				expires: "3000-01-01T00:00:00Z"
+			}
+		}, options);
+		assertFalse(tamperedResult.verified);
+		assertEquals(tamperedResult.reason, {
+			type: "invalidProof",
+			proofIndex: 0
+		});
+		const expiredResult = await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject, { proofOptions: { expires: "2000-01-01T00:00:00Z" } }), options);
+		assertFalse(expiredResult.verified);
+		assertEquals(expiredResult.reason, {
+			type: "invalidProof",
+			proofIndex: 0
+		});
+	});
+	await t.step("verifies aliased proof properties", async () => {
+		const proofAlias = "integrityProof";
+		const proofIri = "https://w3id.org/security#proof";
+		for (const { context, proofProperty, typeProperty, type } of [
+			{
+				context: { [proofAlias]: proofIri },
+				proofProperty: proofAlias,
+				typeProperty: "type",
+				type: "Note"
+			},
+			{
+				context: { PortableNote: {
+					"@id": "https://www.w3.org/ns/activitystreams#Note",
+					"@context": { [proofAlias]: proofIri }
+				} },
+				proofProperty: proofAlias,
+				typeProperty: "type",
+				type: "PortableNote"
+			},
+			{
+				context: {
+					kind: "@type",
+					PortableNote: {
+						"@id": "https://www.w3.org/ns/activitystreams#Note",
+						"@context": { [proofAlias]: proofIri }
+					}
+				},
+				proofProperty: proofAlias,
+				typeProperty: "kind",
+				type: "PortableNote"
+			},
+			{
+				context: { sec: "https://w3id.org/security#" },
+				proofProperty: "sec:proof",
+				typeProperty: "type",
+				type: "Note"
+			},
+			{
+				context: { sec: {
+					"@id": "https://w3id.org/security#",
+					"@prefix": true
+				} },
+				proofProperty: "sec:proof",
+				typeProperty: "type",
+				type: "Note"
+			}
+		]) {
+			const document = {
+				...unsignedObject,
+				"@context": [...portableContext, context]
+			};
+			delete document.type;
+			document[typeProperty] = type;
+			const { proof, ...signed } = await signPortableJsonLd(document);
+			const result = await verifyPortableObjectProof({
+				...signed,
+				[proofProperty]: proof
+			}, options);
+			assert(result.verified);
+			assertEquals(result.keys.length, 1);
+			assertEquals(result.keys[0].id, portableKeyId);
+		}
+	});
+	await t.step("verifies proof aliases from caller-loaded contexts", async () => {
+		const contextUrl = "https://context.example/security";
+		const proofAlias = "integrityProof";
+		const proofIri = "https://w3id.org/security#proof";
+		let contextLoads = 0;
+		const contextLoader = async (url) => {
+			if (url !== contextUrl) return await mockDocumentLoader(url);
+			contextLoads++;
+			return {
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": { [proofAlias]: proofIri } }
+			};
+		};
+		const { proof, ...signed } = await signPortableJsonLd({
+			...unsignedObject,
+			"@context": [...portableContext, contextUrl]
+		});
+		const result = await verifyPortableObjectProof({
+			...signed,
+			[proofAlias]: proof
+		}, {
+			...options,
+			contextLoader
+		});
+		assert(result.verified);
+		assertEquals(result.keys.length, 1);
+		assertEquals(result.keys[0].id, portableKeyId);
+		assertEquals(contextLoads, 1);
+	});
+	await t.step("verifies portable actors and activities by shape", async () => {
+		for (const document of [{
+			"@context": portableActorContext,
+			id: `ap+ef61://did:key:${portableDidMethod}/actor`,
+			type: "UnknownActorType",
+			inbox: "https://gateway.example/users/alice/inbox",
+			outbox: "https://gateway.example/users/alice/outbox",
+			gateways: ["https://gateway.example"]
+		}, {
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/activities/1`,
+			type: "UnknownActivityType",
+			actor: `ap://did:key:${portableDidMethod}/actor`,
+			object: objectId
+		}]) {
+			const result = await verifyPortableObjectProof(await signPortableJsonLd(document), options);
+			assert(result.verified);
+			assertEquals(result.keys.length, 1);
+		}
+	});
+	await t.step("requires portable actors to have valid gateways", async () => {
+		const actorIds = [
+			`ap://did:key:${portableDidMethod}/actor`,
+			`ap+ef61://did%3Akey%3A${portableDidMethod}/actor`,
+			`https://gateway.example/.well-known/apgateway/did:key:${portableDidMethod}/actor`
+		];
+		const actor = (id, extra) => ({
+			"@context": portableActorContext,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`,
+			...extra
+		});
+		const validGateways = [
+			["https://gateway.example"],
+			["https://gateway.example/"],
+			["https://gateway.example", "http://other.example:8080"]
+		];
+		const invalidGateways = [
+			{},
+			{ gateways: [] },
+			{ gateways: ["https://gateway.example/path"] },
+			{ gateways: ["https://gateway.example/?query"] },
+			{ gateways: ["https://gateway.example/?"] },
+			{ gateways: ["https://gateway.example/#fragment"] },
+			{ gateways: ["https://gateway.example/#"] },
+			{ gateways: ["ftp://gateway.example"] },
+			{ gateways: ["https://user:password@gateway.example"] },
+			{ gateways: ["gateway.example"] },
+			{ gateways: ["https://gateway.example", "https://other.example/path"] }
+		];
+		for (const id of actorIds) {
+			for (const gateways of validGateways) assert((await verifyPortableObjectProof(await signPortableJsonLd(actor(id, { gateways })), options)).verified, `${id} with ${gateways}`);
+			for (const extra of invalidGateways) assertEquals(await verifyPortableObjectProof(await signPortableJsonLd(actor(id, extra)), options), {
+				verified: false,
+				reason: { type: "invalidGateways" }
+			}, `${id} with ${JSON.stringify(extra)}`);
+		}
+	});
+	await t.step("reads gateways in any JSON-LD form", async () => {
+		const id = `ap://did:key:${portableDidMethod}/actor`;
+		const property = "https://w3id.org/fep/ef61/gateways";
+		const documents = [
+			{
+				"@context": portableContext,
+				[property]: { "@list": [{ "@id": "https://gateway.example" }] }
+			},
+			{
+				"@context": portableContext,
+				[property]: "https://gateway.example"
+			},
+			{
+				"@context": [...portableContext, { relays: {
+					"@id": property,
+					"@type": "@id",
+					"@container": "@list"
+				} }],
+				relays: ["https://gateway.example"]
+			}
+		];
+		for (const document of documents) assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			...document,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`
+		}), options)).verified, JSON.stringify(document));
+		assertEquals(await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`,
+			[property]: [{ "@list": [{ "@id": "https://gateway.example" }] }, { "@list": [{ "@id": "https://other.example" }] }]
+		}), options), {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		});
+	});
+	await t.step("verifies JCS-signed actors with unmapped gateways", async () => {
+		for (const id of [`ap+ef61://${portableDid}/actor`, `https://gateway.example/.well-known/apgateway/${portableDid}/actor`]) {
+			const signed = await signPortableJsonLd({
+				"@context": portableContext,
+				id,
+				type: "Person",
+				inbox: `${id}/inbox`,
+				outbox: `${id}/outbox`,
+				gateways: ["https://gateway.example", "https://other.example"]
+			});
+			const original = structuredClone(signed);
+			assert((await verifyPortableObjectProof(signed, options)).verified);
+			assertEquals(signed, original);
+			assertEquals(await verifyPortableObjectProof({
+				...signed,
+				gateways: ["https://attacker.example"]
+			}, options), {
+				verified: false,
+				reason: {
+					type: "invalidProof",
+					proofIndex: 0
+				}
+			});
+		}
+	});
+	await t.step("rejects malformed unmapped actor gateways", async () => {
+		const id = `ap+ef61://${portableDid}/actor`;
+		for (const gateways of [
+			[],
+			["https://gateway.example", 42],
+			[{ bad: "https://gateway.example" }],
+			["ftp://gateway.example"],
+			["https://gateway.example/path"],
+			["https://gateway.example/?query"],
+			["https://gateway.example/#fragment"],
+			["https://user:password@gateway.example"]
+		]) assertEquals(await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`,
+			gateways
+		}), options), {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		}, JSON.stringify(gateways));
+	});
+	await t.step("does not replace context-defined gateway semantics", async () => {
+		const id = `ap+ef61://${portableDid}/actor`;
+		const actor = {
+			"@context": portableContext,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`,
+			gateways: ["https://gateway.example"]
+		};
+		const property = "https://w3id.org/fep/ef61/gateways";
+		for (const extra of [
+			{ [property]: { "@list": [] } },
+			{ [property]: { "@list": [{ "@id": "https://bad.example/path" }] } },
+			{ "@context": [...portableContext, { gateways: null }] },
+			{ "@context": [...portableContext, { gateways: "https://other.example/gateways" }] },
+			{ "@context": [...portableContext, { Person: {
+				"@id": "https://www.w3.org/ns/activitystreams#Person",
+				"@context": { gateways: null }
+			} }] }
+		]) assertEquals(await verifyPortableObjectProof(await signPortableJsonLd({
+			...actor,
+			...extra
+		}), options), {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		}, JSON.stringify(extra));
+		assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			...actor,
+			gateways: ["https://bad.example/path"],
+			[property]: { "@list": [{ "@id": "https://canonical.example" }] }
+		}), options)).verified);
+		assertEquals(await verifyPortableObjectProof(await signPortableJsonLd(actor, { proofOptions: { cryptosuite: "eddsa-rdfc-2022" } }), options), {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		});
+	});
+	await t.step("checks gateways only for FEP-2277 actors", async () => {
+		assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/actor`,
+			type: "Person",
+			inbox: `ap://did:key:${portableDidMethod}/actor/inbox`
+		}), options)).verified);
+		assert((await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject), options)).verified);
+	});
+	await t.step("checks gateways after the proof shape and before the keys", async () => {
+		const id = `ap://did:key:${portableDidMethod}/actor`;
+		const document = {
+			"@context": portableActorContext,
+			id,
+			type: "Person",
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`
+		};
+		assertEquals(await verifyPortableObjectProof(document, options), {
+			verified: false,
+			reason: { type: "missingProof" }
+		});
+		const keyIds = [];
+		const keyCache = {
+			get(keyId) {
+				keyIds.push(keyId.href);
+				return Promise.resolve(void 0);
+			},
+			set(keyId) {
+				keyIds.push(keyId.href);
+				return Promise.resolve();
+			}
+		};
+		assertEquals(await verifyPortableObjectProof({
+			...await signPortableJsonLd(document),
+			name: "Tampered"
+		}, {
+			...options,
+			keyCache
+		}), {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		});
+		assertEquals(keyIds, []);
+		assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			...document,
+			gateways: ["https://gateway.example"]
+		}), {
+			...options,
+			keyCache
+		})).verified);
+		assert(keyIds.length > 0);
+	});
+	await t.step("uses the normative FEP-2277 precedence order", async () => {
+		for (const document of [{
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/actor`,
+			type: "Collection",
+			inbox: "https://gateway.example/users/alice/inbox",
+			outbox: "https://gateway.example/users/alice/outbox",
+			totalItems: 0
+		}, {
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/activities/1`,
+			type: "Collection",
+			actor: `ap://did:key:${portableDidMethod}/actor`,
+			totalItems: 0
+		}]) assertEquals(await verifyPortableObjectProof(document, options), {
+			verified: false,
+			reason: { type: "missingProof" }
+		});
+	});
+	await t.step("accepts portable URI spelling and location-hint variants", async () => {
+		const variants = [
+			`ap+ef61://did%3Akey%3A${portableDidMethod}/objects/1`,
+			`AP://did:key:${portableDidMethod}/objects/1`,
+			`ap://did:key:${portableDidMethod}/objects/1?%40gateway=${encodeURIComponent("https://gateway.example")}`,
+			`ap://did:key:${portableDidMethod}/objects/1#content`
+		];
+		for (const id of variants) assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			...unsignedObject,
+			id
+		}), options)).verified, id);
+	});
+	await t.step("supports matching DID methods resolved by a caller", async () => {
+		const verificationMethod = new URL("did:web:example.com#key");
+		const document = {
+			...unsignedObject,
+			id: "ap://did:web:example.com/objects/1"
+		};
+		let fetches = 0;
+		assert((await verifyPortableObjectProof(await signPortableJsonLd(document, { verificationMethod }), {
+			contextLoader: mockDocumentLoader,
+			documentLoader: async (url) => {
+				fetches++;
+				assertEquals(url, verificationMethod.href);
+				return {
+					contextUrl: null,
+					documentUrl: url,
+					document: {
+						"@context": "https://w3id.org/security/multikey/v1",
+						id: verificationMethod.href,
+						type: "Multikey",
+						controller: "did:web:example.com",
+						publicKeyMultibase: await exportMultibaseKey(ed25519PublicKey.publicKey)
+					}
+				};
+			}
+		})).verified);
+		assertEquals(fetches, 1);
+	});
+	await t.step("caches keys owned by their own DID", async () => {
+		const verificationMethod = new URL("did:web:example.com#key");
+		const document = {
+			...unsignedObject,
+			id: "ap://did:web:example.com/objects/1"
+		};
+		const cached = [];
+		assert((await verifyPortableObjectProof(await signPortableJsonLd(document, { verificationMethod }), {
+			contextLoader: mockDocumentLoader,
+			keyCache: {
+				get: () => Promise.resolve(void 0),
+				set: (keyId) => {
+					cached.push(keyId.href);
+					return Promise.resolve();
+				}
+			},
+			documentLoader: async (url) => ({
+				contextUrl: null,
+				documentUrl: url,
+				document: {
+					"@context": "https://w3id.org/security/multikey/v1",
+					id: verificationMethod.href,
+					type: "Multikey",
+					controller: "did:web:example.com",
+					publicKeyMultibase: await exportMultibaseKey(ed25519PublicKey.publicKey)
+				}
+			})
+		})).verified);
+		assertEquals(cached, [verificationMethod.href]);
+	});
+	await t.step("rejects a portable key that names another controller", async () => {
+		const verificationMethod = new URL("did:web:example.com#key");
+		assertEquals((await verifyPortableObjectProof(await signPortableJsonLd({
+			...unsignedObject,
+			id: "ap://did:web:example.com/objects/1"
+		}, { verificationMethod }), {
+			contextLoader: mockDocumentLoader,
+			documentLoader: async (url) => ({
+				contextUrl: null,
+				documentUrl: url,
+				document: {
+					"@context": "https://w3id.org/security/multikey/v1",
+					id: verificationMethod.href,
+					type: "Multikey",
+					controller: "did:web:attacker.example",
+					publicKeyMultibase: await exportMultibaseKey(ed25519PublicKey.publicKey)
+				}
+			})
+		})).verified, false);
+	});
+	await t.step("reports a missing proof on portable objects", async () => {
+		assertEquals(await verifyPortableObjectProof(unsignedObject, options), {
+			verified: false,
+			reason: { type: "missingProof" }
+		});
+	});
+	await t.step("treats compatible identifiers as portable IDs", async () => {
+		const compatibleActorId = `https://gateway.example/.well-known/apgateway/did:key:${portableDidMethod}/actor`;
+		const actor = {
+			"@context": portableActorContext,
+			id: compatibleActorId,
+			type: "Person",
+			inbox: `${compatibleActorId}/inbox`,
+			outbox: `${compatibleActorId}/outbox`,
+			gateways: ["https://gateway.example"]
+		};
+		const signed = await signPortableJsonLd(actor);
+		const result = await verifyPortableObjectProof(signed, options);
+		assert(result.verified);
+		assertEquals(result.keys[0].id, portableKeyId);
+		assertEquals(signed.id, compatibleActorId);
+		assertEquals(await verifyPortableObjectProof(actor, options), {
+			verified: false,
+			reason: { type: "missingProof" }
+		});
+		const otherId = `https://gateway.example/.well-known/apgateway/did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK/activities/1`;
+		assertEquals(await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id: otherId,
+			type: "Create",
+			actor: compatibleActorId,
+			object: "https://social.example/objects/1"
+		}), options), {
+			verified: false,
+			reason: {
+				type: "verificationMethodMismatch",
+				proofIndex: 0,
+				objectId: new URL(otherId),
+				verificationMethod: portableKeyId
+			}
+		});
+		await assertRejects(() => verifyPortableObjectProof({
+			...actor,
+			id: `https://user@gateway.example/.well-known/apgateway/did:key:${portableDidMethod}/actor`
+		}, options), TypeError);
+	});
+	await t.step("keeps non-portable documents outside the policy", async () => {
+		for (const document of [
+			{
+				...unsignedObject,
+				id: "https://social.example/objects/1"
+			},
+			{
+				...unsignedObject,
+				id: "https://gateway.example/.well-known/apgateway/hl:zQmdfTbBqBPQ"
+			},
+			{
+				"@context": portableContext,
+				type: "Note",
+				content: "Object without an ID"
+			}
+		]) assertEquals(await verifyPortableObjectProof(document, options), {
+			verified: false,
+			reason: { type: "notPortableObject" }
+		});
+	});
+	await t.step("short-circuits clearly non-portable raw IDs", async () => {
+		let contextLoads = 0;
+		assertEquals(await verifyPortableObjectProof({
+			"@context": "https://attacker.example/context",
+			"@id": "https://social.example/objects/1"
+		}, {
+			...options,
+			contextLoader() {
+				contextLoads++;
+				throw new TypeError("unexpected context load");
+			}
+		}), {
+			verified: false,
+			reason: { type: "notPortableObject" }
+		});
+		assertEquals(contextLoads, 0);
+	});
+	await t.step("distinguishes unsecured and signed collections", async () => {
+		const collection = {
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/collections/1`,
+			type: "Note",
+			totalItems: 0
+		};
+		assertEquals(await verifyPortableObjectProof(collection, options), {
+			verified: false,
+			reason: { type: "unsecuredCollection" }
+		});
+		assert((await verifyPortableObjectProof(await signPortableJsonLd(collection), options)).verified);
+	});
+	await t.step("classifies unsupported core types without using type", async () => {
+		const cases = [
+			{
+				document: {
+					...unsignedObject,
+					href: "https://example.com/"
+				},
+				objectType: "link"
+			},
+			{
+				document: {
+					...unsignedObject,
+					"https://w3id.org/security#publicKeyMultibase": "z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2"
+				},
+				objectType: "verificationMethod"
+			},
+			{
+				document: {
+					...unsignedObject,
+					"https://w3id.org/security#publicKeyPem": "not-a-real-key"
+				},
+				objectType: "publicKey"
+			}
+		];
+		for (const { document, objectType } of cases) assertEquals(await verifyPortableObjectProof(document, options), {
+			verified: false,
+			reason: {
+				type: "unsupportedObjectType",
+				objectType
+			}
+		});
+	});
+	await t.step("rejects non-DID verification methods before fetching", async () => {
+		let fetched = false;
+		const verificationMethod = new URL("https://attacker.example/keys/ed25519");
+		const result = await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject, { verificationMethod }), {
+			contextLoader: mockDocumentLoader,
+			documentLoader() {
+				fetched = true;
+				throw new TypeError("unexpected fetch");
+			}
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason, {
+			type: "unsupportedVerificationMethod",
+			proofIndex: 0,
+			verificationMethod
+		});
+		assertFalse(fetched);
+	});
+	await t.step("rejects malformed DID verification methods", async () => {
+		const verificationMethod = new URL("did:invalid");
+		const result = await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject, { verificationMethod }), options);
+		assertFalse(result.verified);
+		assertEquals(result.reason, {
+			type: "unsupportedVerificationMethod",
+			proofIndex: 0,
+			verificationMethod
+		});
+	});
+	await t.step("rejects a proof from another DID before fetching", async () => {
+		let fetched = false;
+		const verificationMethod = new URL("did:key:z6MkMallory#z6MkMallory");
+		const result = await verifyPortableObjectProof(await signPortableJsonLd(unsignedObject, { verificationMethod }), {
+			contextLoader: mockDocumentLoader,
+			documentLoader() {
+				fetched = true;
+				throw new TypeError("unexpected fetch");
+			}
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason, {
+			type: "verificationMethodMismatch",
+			proofIndex: 0,
+			objectId: parseIri(objectId),
+			verificationMethod
+		});
+		assertFalse(fetched);
+	});
+	await t.step("rejects proofs with multiple verification methods", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		for (const additionalVerificationMethod of ["did:key:z6MkMallory#z6MkMallory", "https://attacker.example/key"]) assertEquals(await verifyPortableObjectProof({
+			...signed,
+			proof: {
+				...proof,
+				verificationMethod: [portableKeyId.href, additionalVerificationMethod]
+			}
+		}, options), {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: 0
+			}
+		});
+	});
+	await t.step("rejects multiple values in functional proof fields", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		const cases = [
+			["cryptosuite", "eddsa-jcs-2022"],
+			["proofPurpose", "authentication"],
+			["proofValue", proof.proofValue],
+			["created", "2024-01-01T00:00:00Z"]
+		];
+		for (const [field, additionalValue] of cases) {
+			const originalValue = proof[field];
+			assert(originalValue != null);
+			assertEquals(await verifyPortableObjectProof({
+				...signed,
+				proof: {
+					...proof,
+					[field]: [originalValue, additionalValue]
+				}
+			}, options), {
+				verified: false,
+				reason: {
+					type: "invalidProof",
+					proofIndex: 0
+				}
+			});
+		}
+	});
+	await t.step("requires exactly the DataIntegrityProof type", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		const missingType = { ...proof };
+		delete missingType.type;
+		for (const invalidProof of [
+			missingType,
+			{
+				...proof,
+				type: "Object"
+			},
+			{
+				...proof,
+				type: ["DataIntegrityProof", "Object"]
+			}
+		]) assertEquals(await verifyPortableObjectProof({
+			...signed,
+			proof: invalidProof
+		}, options), {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: 0
+			}
+		});
+	});
+	await t.step("reports cryptographic failures separately", async () => {
+		assertEquals(await verifyPortableObjectProof({
+			...await signPortableJsonLd(unsignedObject),
+			content: "Tampered"
+		}, options), {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: 0
+			}
+		});
+	});
+	await t.step("reports malformed proof structures as invalid", async () => {
+		for (const proof of [{ type: "DataIntegrityProof" }, {
+			type: "DataIntegrityProof",
+			cryptosuite: "eddsa-jcs-2022",
+			verificationMethod: portableKeyId.href,
+			proofPurpose: "assertionMethod",
+			proofValue: "zInvalid",
+			created: "not-an-instant"
+		}]) assertEquals(await verifyPortableObjectProof({
+			...unsignedObject,
+			proof
+		}, options), {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: 0
+			}
+		});
+	});
+	await t.step("accepts multiple valid proofs in input order", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		const result = await verifyPortableObjectProof({
+			...signed,
+			proof: [proof, structuredClone(proof)]
+		}, options);
+		assert(result.verified);
+		assertEquals(result.keys.length, 2);
+		assertEquals(result.keys.map((key) => key.id), [portableKeyId, portableKeyId]);
+	});
+	await t.step("rejects a tampered duplicate proof", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		assertFalse((await verifyPortableObjectProof({
+			...signed,
+			proof: [proof, {
+				...structuredClone(proof),
+				expires: "3000-01-01T00:00:00Z"
+			}]
+		}, options)).verified);
+	});
+	await t.step("matches proofs across aliased properties", async () => {
+		const document = {
+			...unsignedObject,
+			"@context": [...portableContext, {
+				firstProof: "https://w3id.org/security#proof",
+				secondProof: "https://w3id.org/security#proof"
+			}]
+		};
+		const firstSigned = await signPortableJsonLd(document, { proofOptions: { domain: "first.example" } });
+		const secondSigned = await signPortableJsonLd(document, { proofOptions: { domain: "second.example" } });
+		const result = await verifyPortableObjectProof({
+			...document,
+			secondProof: secondSigned.proof,
+			firstProof: firstSigned.proof
+		}, options);
+		assert(result.verified);
+		assertEquals(result.keys.length, 2);
+	});
+	await t.step("canonicalizes the document only once for multiple proofs", async () => {
+		async function countContentReads(proofCount) {
+			const signed = await signPortableJsonLd(unsignedObject);
+			const proof = signed.proof;
+			const document = {
+				...signed,
+				proof: Array.from({ length: proofCount }, () => structuredClone(proof))
+			};
+			let contentReads = 0;
+			Object.defineProperty(document, "content", {
+				configurable: true,
+				enumerable: true,
+				get() {
+					contentReads++;
+					return unsignedObject.content;
+				}
+			});
+			const result = await verifyPortableObjectProof(document, options);
+			assert(result.verified);
+			assertEquals(result.keys.length, proofCount);
+			return contentReads;
+		}
+		assertEquals(await countContentReads(3), await countContentReads(1));
+	});
+	await t.step("requires every proof to verify", async () => {
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		assertEquals(await verifyPortableObjectProof({
+			...signed,
+			proof: [proof, {
+				...proof,
+				proofValue: "zInvalid"
+			}]
+		}, options), {
+			verified: false,
+			reason: {
+				type: "invalidProof",
+				proofIndex: 1
+			}
+		});
+	});
+	await t.step("checks every proof policy before resolving keys", async () => {
+		const didWebId = "ap://did:web:example.com/objects/1";
+		const didWebMethod = new URL("did:web:example.com#key");
+		const didWebSigned = await signPortableJsonLd({
+			...unsignedObject,
+			id: didWebId
+		}, { verificationMethod: didWebMethod });
+		const httpMethod = new URL("https://attacker.example/key");
+		const httpSigned = await signPortableJsonLd({
+			...unsignedObject,
+			id: didWebId
+		}, { verificationMethod: httpMethod });
+		let fetched = false;
+		const result = await verifyPortableObjectProof({
+			...didWebSigned,
+			proof: [didWebSigned.proof, httpSigned.proof]
+		}, {
+			contextLoader: mockDocumentLoader,
+			documentLoader() {
+				fetched = true;
+				throw new TypeError("unexpected fetch");
+			}
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason, {
+			type: "unsupportedVerificationMethod",
+			proofIndex: 1,
+			verificationMethod: httpMethod
+		});
+		assertFalse(fetched);
+	});
+	await t.step("accepts the expanded proof property", async () => {
+		const { proof, ...document } = await signPortableJsonLd(unsignedObject);
+		const expandedProof = await (await DataIntegrityProof.fromJsonLd(proof, {
+			contextLoader: mockDocumentLoader,
+			documentLoader: mockDocumentLoader
+		})).toJsonLd({
+			format: "expand",
+			contextLoader: mockDocumentLoader
+		});
+		assert((await verifyPortableObjectProof({
+			...document,
+			"https://w3id.org/security#proof": expandedProof
+		}, options)).verified);
+	});
+	await t.step("classifies JSON-LD aliases by their expanded properties", async () => {
+		assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": [...portableContext, { performedBy: "https://www.w3.org/ns/activitystreams#actor" }],
+			id: `ap://did:key:${portableDidMethod}/activities/aliased`,
+			type: "UnknownActivity",
+			performedBy: `ap://did:key:${portableDidMethod}/actor`
+		}), options)).verified);
+	});
+	await t.step("does not claim to verify embedded portable objects", async () => {
+		assert((await verifyPortableObjectProof(await signPortableJsonLd({
+			"@context": portableContext,
+			id: `ap://did:key:${portableDidMethod}/activities/outer`,
+			type: "Create",
+			actor: `ap://did:key:${portableDidMethod}/actor`,
+			object: {
+				id: `ap://did:key:${portableDidMethod}/objects/embedded`,
+				type: "Note",
+				content: "Unsigned embedded object"
+			}
+		}), options)).verified);
+	});
+	await t.step("rejects malformed roots and portable IDs", async () => {
+		await assertRejects(() => verifyPortableObjectProof([], options), TypeError, "single JSON-LD object");
+		await assertRejects(() => verifyPortableObjectProof({
+			...unsignedObject,
+			id: `ap://did:key:${portableDidMethod}`
+		}, options), TypeError);
+		await assertRejects(() => verifyPortableObjectProof({
+			...unsignedObject,
+			id: "ap://did%ZZkey/objects/1"
+		}, options), TypeError);
+	});
+	await t.step("emits metrics only for attempted proof verification", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const signed = await signPortableJsonLd(unsignedObject);
+		const proof = signed.proof;
+		assert((await verifyPortableObjectProof({
+			...signed,
+			proof: [proof, structuredClone(proof)]
+		}, {
+			...options,
+			meterProvider
+		})).verified);
+		assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 2);
+		const [rejectedMeterProvider, rejectedRecorder] = createTestMeterProvider();
+		await verifyPortableObjectProof(unsignedObject, {
+			...options,
+			meterProvider: rejectedMeterProvider
+		});
+		assertEquals(rejectedRecorder.getMeasurements("activitypub.signature.verification.duration").length, 0);
+	});
+});
 test("verifyObject()", async () => {
 	const options = {
 		documentLoader: mockDocumentLoader,
@@ -593,7 +1851,7 @@ test("verifyObject()", async () => {
 test("verifyObject() accepts did:key proofs for matching portable attribution origin", async () => {
 	const did = await exportDidKey(ed25519PublicKey.publicKey);
 	const keyId = new URL(`${did}#${did.substring(8)}`);
-	const verified = await verifyObject(Note, await (await signObject(new Note({
+	const jsonLd = await (await signObject(new Note({
 		id: parseIri(`ap://did:key:${did.substring(8)}/objects/1`),
 		attribution: parseIri(`ap://did:key:${did.substring(8)}/actor`),
 		content: "Portable note"
@@ -604,7 +1862,8 @@ test("verifyObject() accepts did:key proofs for matching portable attribution or
 		format: "compact",
 		contextLoader: mockDocumentLoader,
 		context: ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"]
-	}), {
+	});
+	const verified = await verifyObject(Note, jsonLd, {
 		documentLoader() {
 			throw new TypeError("did:key must not use the document loader");
 		},
@@ -612,6 +1871,199 @@ test("verifyObject() accepts did:key proofs for matching portable attribution or
 	});
 	assertInstanceOf(verified, Note);
 	assertEquals(verified.content, "Portable note");
+	assert(typeof jsonLd === "object" && jsonLd != null && !Array.isArray(jsonLd));
+	const rawProof = jsonLd.proof;
+	assert(typeof rawProof === "object" && rawProof != null && !Array.isArray(rawProof));
+	assertEquals(await verifyObject(Note, {
+		...jsonLd,
+		proof: [rawProof, {
+			...structuredClone(rawProof),
+			expires: "3000-01-01T00:00:00Z"
+		}]
+	}, {
+		documentLoader() {
+			throw new TypeError("did:key must not use the document loader");
+		},
+		contextLoader: mockDocumentLoader
+	}), null);
+	async function verifyRemotelyReferencedProof(proofOptions = {}, proofUrl = "https://proof.example/proofs/1") {
+		const remotelyReferencedJsonLd = { ...jsonLd };
+		delete remotelyReferencedJsonLd.proof;
+		remotelyReferencedJsonLd["https://w3id.org/security#proof"] = [{ "@graph": [rawProof] }, { "@graph": [{ "@id": proofUrl }] }];
+		let proofFetches = 0;
+		const result = await verifyObject(Note, remotelyReferencedJsonLd, {
+			documentLoader(url) {
+				if (url !== formatIri(parseIri(proofUrl))) throw new TypeError(`unexpected document URL: ${url}`);
+				proofFetches++;
+				return Promise.resolve({
+					contextUrl: null,
+					document: {
+						"@context": jsonLd["@context"],
+						...structuredClone(rawProof),
+						...proofOptions
+					},
+					documentUrl: url
+				});
+			},
+			contextLoader: mockDocumentLoader
+		});
+		assertEquals(proofFetches, 1);
+		return result;
+	}
+	assertInstanceOf(await verifyRemotelyReferencedProof(), Note);
+	assertInstanceOf(await verifyRemotelyReferencedProof({}, `ap://did:key:${did.substring(8)}/proofs/1`), Note);
+	assertEquals(await verifyRemotelyReferencedProof({ expires: "3000-01-01T00:00:00Z" }), null);
+});
+test("verifyObject() hydrates pending proof references", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const method = did.substring(8);
+	const keyId = new URL(`${did}#${method}`);
+	const proofUrl = `ap://did:key:${method}/proofs/1`;
+	const signed = await signPortableJsonLd({
+		"@context": portableContext,
+		id: `ap://did:key:${method}/objects/1`,
+		type: "Note",
+		attributedTo: `ap://did:key:${method}/actor`,
+		content: "Portable note with a referenced proof"
+	}, {
+		verificationMethod: keyId,
+		proofOptions: { id: proofUrl }
+	});
+	const rawProof = signed.proof;
+	const remotelyReferencedJsonLd = { ...signed };
+	delete remotelyReferencedJsonLd.proof;
+	remotelyReferencedJsonLd["https://w3id.org/security#proof"] = [{ "@graph": [rawProof] }, { "@graph": [{ "@id": proofUrl }] }];
+	let proofFetches = 0;
+	const verified = await verifyObject(Note, remotelyReferencedJsonLd, {
+		documentLoader(url) {
+			assertEquals(url, formatIri(parseIri(proofUrl)));
+			proofFetches++;
+			return Promise.resolve({
+				contextUrl: null,
+				document: structuredClone(rawProof),
+				documentUrl: url
+			});
+		},
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(proofFetches, 1);
+	assertInstanceOf(verified, Note);
+});
+test("verifyObject() does not pass its proof verifier on to cached proofs", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const method = did.substring(8);
+	const keyId = new URL(`${did}#${method}`);
+	const proofUrl = `ap://did:key:${method}/proofs/1`;
+	const signed = await signPortableJsonLd({
+		"@context": portableContext,
+		id: `ap://did:key:${method}/objects/1`,
+		type: "Note",
+		attributedTo: `ap://did:key:${method}/actor`,
+		content: "Portable note with a referenced proof"
+	}, {
+		verificationMethod: keyId,
+		proofOptions: { id: proofUrl }
+	});
+	const rawProof = signed.proof;
+	const referencedJsonLd = { ...signed };
+	delete referencedJsonLd.proof;
+	referencedJsonLd["https://w3id.org/security#proof"] = [{ "@graph": [rawProof] }, { "@graph": [{ "@id": proofUrl }] }];
+	const rootVerifier = async () => ({ verified: false });
+	for (const verifyPortableObject of [void 0, rootVerifier]) {
+		let proofFetches = 0;
+		const verified = await verifyObject(Note, referencedJsonLd, {
+			documentLoader(url) {
+				proofFetches++;
+				return Promise.resolve({
+					contextUrl: null,
+					document: structuredClone(rawProof),
+					documentUrl: url
+				});
+			},
+			contextLoader: mockDocumentLoader,
+			...verifyPortableObject == null ? {} : { verifyPortableObject }
+		});
+		assertInstanceOf(verified, Note);
+		assertEquals(proofFetches, 1);
+		const proofs = await Array.fromAsync(verified.getProofs());
+		assertEquals(proofs.length, 2);
+		assertEquals(proofFetches, 1);
+		for (const proof of proofs) assert(proof._verifyPortableObject === verifyPortableObject);
+	}
+});
+test("verifyObject() hydrates portable proof references with gateway hints", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const method = did.substring(8);
+	const keyId = new URL(`${did}#${method}`);
+	const proofId = `ap://did:key:${method}/proofs/1`;
+	const proofReference = `${proofId}?@gateway=https%3A%2F%2Fgateway.example`;
+	const signed = await signPortableJsonLd({
+		"@context": portableContext,
+		id: `ap://did:key:${method}/objects/1`,
+		type: "Note",
+		attributedTo: `ap://did:key:${method}/actor`,
+		content: "Portable note with a hinted proof reference"
+	}, {
+		verificationMethod: keyId,
+		proofOptions: { id: proofId }
+	});
+	const rawProof = signed.proof;
+	const referencedJsonLd = { ...signed };
+	delete referencedJsonLd.proof;
+	referencedJsonLd["https://w3id.org/security#proof"] = [{ "@graph": [rawProof] }, { "@graph": [{ "@id": proofReference }] }];
+	const fetched = [];
+	const verified = await verifyObject(Note, referencedJsonLd, {
+		documentLoader(url) {
+			fetched.push(url);
+			return Promise.resolve({
+				contextUrl: null,
+				document: structuredClone(rawProof),
+				documentUrl: url
+			});
+		},
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(fetched, [formatIri(parseIri(proofReference))]);
+	assertInstanceOf(verified, Note);
+});
+test("verifyObject() rejects portable proof references it cannot dereference", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const method = did.substring(8);
+	const keyId = new URL(`${did}#${method}`);
+	const proofUrl = `ap://did:key:${method}/proofs/2`;
+	const signed = await signPortableJsonLd({
+		"@context": portableContext,
+		id: `ap://did:key:${method}/objects/1`,
+		type: "Note",
+		attributedTo: `ap://did:key:${method}/actor`,
+		content: "Portable note with an extra referenced proof"
+	}, { verificationMethod: keyId });
+	const rawProof = signed.proof;
+	const withProofs = (proofs) => {
+		const referencedJsonLd = { ...signed };
+		delete referencedJsonLd.proof;
+		referencedJsonLd["https://w3id.org/security#proof"] = proofs;
+		return referencedJsonLd;
+	};
+	const embedded = { "@graph": [rawProof] };
+	const referenced = { "@graph": [{ "@id": proofUrl }] };
+	for (const [id, referencedJsonLd] of [
+		[`ap://did:key:${method}/proofs/3`, withProofs([embedded, referenced])],
+		[`ap://did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK/proofs/2`, withProofs([embedded, referenced])],
+		[`ap://did:key:${method}/proofs/3`, withProofs([referenced, embedded])]
+	]) assertEquals(await verifyObject(Note, referencedJsonLd, {
+		documentLoader(url) {
+			return Promise.resolve({
+				contextUrl: null,
+				document: {
+					...rawProof,
+					id
+				},
+				documentUrl: url
+			});
+		},
+		contextLoader: mockDocumentLoader
+	}), null);
 });
 test("verifyObject() accepts multiple portable attributions from the same did:key origin", async () => {
 	const did = await exportDidKey(ed25519PublicKey.publicKey);
@@ -727,5 +2179,290 @@ test("verifyObject() rejects did:key proofs from another portable attribution or
 		contextLoader: mockDocumentLoader
 	}), null);
 });
+async function signCompatibleNote(attribution, keyId) {
+	const context = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+	return await (await signObject(new Note({
+		id: new URL(`${attribution}/notes/1`),
+		attribution: new URL(attribution),
+		content: "Note of a compatible-ID actor"
+	}), ed25519PrivateKey, keyId, {
+		contextLoader: mockDocumentLoader,
+		context
+	})).toJsonLd({
+		format: "compact",
+		contextLoader: mockDocumentLoader,
+		context
+	});
+}
+test("verifyObject() authenticates compatible-ID attributions by DID proofs", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const keyId = new URL(`${did}#${did.substring(8)}`);
+	const options = {
+		documentLoader() {
+			throw new TypeError("did:key must not use the document loader");
+		},
+		contextLoader: mockDocumentLoader
+	};
+	for (const gateway of ["https://gw1.example", "https://gw2.example"]) assertInstanceOf(await verifyObject(Note, await signCompatibleNote(`${gateway}/.well-known/apgateway/${did}/actor`, keyId), options), Note);
+	assertEquals(await verifyObject(Note, await signCompatibleNote("https://gw1.example/.well-known/apgateway/did:key:z6MkOther/actor", keyId), options), null);
+});
+test("verifyObject() does not trust compatible-ID actors by web origin", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const attribution = `https://evil.example/.well-known/apgateway/${did}/actor`;
+	const keyId = new URL("https://evil.example/keys/1");
+	const documents = {
+		[keyId.href]: {
+			"@context": "https://w3id.org/security/multikey/v1",
+			id: keyId.href,
+			type: "Multikey",
+			controller: attribution,
+			publicKeyMultibase: await exportMultibaseKey(ed25519PublicKey.publicKey)
+		},
+		[attribution]: {
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/multikey/v1"],
+			id: attribution,
+			type: "Person",
+			inbox: `${attribution}/inbox`,
+			assertionMethod: keyId.href
+		}
+	};
+	const fetched = [];
+	assertEquals(await verifyObject(Note, await signCompatibleNote(attribution, keyId), {
+		documentLoader: (url) => {
+			fetched.push(url);
+			const document = documents[url];
+			if (document == null) throw new TypeError(`Unexpected: ${url}`);
+			return Promise.resolve({
+				contextUrl: null,
+				documentUrl: url,
+				document
+			});
+		},
+		contextLoader: mockDocumentLoader
+	}), null);
+	assertEquals(fetched, [keyId.href]);
+	assertEquals(await verifyObject(Note, await signCompatibleNote(`https://user@gw.example/.well-known/apgateway/${did}/actor`, new URL(`${did}#${did.substring(8)}`)), { contextLoader: mockDocumentLoader }), null);
+});
+test("signObject() preserves FEP-22cd contexts through proof verification", async () => {
+	const did = await exportDidKey(ed25519PublicKey.publicKey);
+	const keyId = new URL(`${did}#${did.substring(8)}`);
+	const id = parseIri(`ap://${did}/objects/translation`);
+	const json = await (await signObject(new Note({
+		id,
+		attribution: parseIri(`ap://${did}/actor`),
+		content: "A translated note",
+		translations: [new Translation({
+			language: new Intl.Locale("ko"),
+			translator: new URL("https://example.com/translator"),
+			original: id
+		})]
+	}), ed25519PrivateKey, keyId)).toJsonLd({ format: "compact" });
+	assert(typeof json === "object" && json != null && "@context" in json && "proof" in json);
+	assertEquals(json.proof["@context"], json["@context"]);
+	const verified = await verifyObject(Note, json, { documentLoader() {
+		throw new Error("No document fetch expected");
+	} });
+	assertInstanceOf(verified, Note);
+	assertEquals(verified.translations[0].language?.baseName, "ko");
+});
+test("verifyObject() rejects a key that claims a forged controller", async () => {
+	const keyId = new URL("https://attacker.example/multikey");
+	const impersonated = "https://example.com/person2";
+	const attackerActor = "https://attacker.example/actor";
+	const multikeyDocument = await ed25519Multikey.toJsonLd({ contextLoader: mockDocumentLoader });
+	const options = {
+		format: "compact",
+		contextLoader: mockDocumentLoader,
+		documentLoader: mockDocumentLoader,
+		context: ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"]
+	};
+	const signed = await signObject(new Create({
+		id: new URL("https://attacker.example/activities/1"),
+		actor: new URL(impersonated),
+		object: new Note({
+			id: new URL("https://attacker.example/notes/1"),
+			attribution: new URL(impersonated),
+			content: "Hello world"
+		})
+	}), ed25519PrivateKey, keyId, options);
+	const jsonLd = await signed.toJsonLd(options);
+	const serveKeyControlledBy = (controller) => (resource) => {
+		if (resource === keyId.href) return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: {
+				...multikeyDocument,
+				id: keyId.href,
+				controller
+			}
+		});
+		if (resource === attackerActor) return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: {
+				"@context": [
+					"https://www.w3.org/ns/activitystreams",
+					"https://w3id.org/security/v1",
+					"https://w3id.org/security/multikey/v1",
+					"https://w3id.org/security/data-integrity/v1",
+					"https://www.w3.org/ns/did/v1"
+				],
+				id: resource,
+				type: "Person",
+				assertionMethod: [keyId.href]
+			}
+		});
+		return mockDocumentLoader(resource);
+	};
+	assertEquals(await verifyObject(Create, jsonLd, {
+		documentLoader: serveKeyControlledBy(impersonated),
+		contextLoader: mockDocumentLoader
+	}), null);
+	const honestLoader = serveKeyControlledBy(attackerActor);
+	let proof = null;
+	for await (const p of signed.getProofs(options)) {
+		proof = p;
+		break;
+	}
+	assertInstanceOf(proof, DataIntegrityProof);
+	assertInstanceOf(await verifyProof(jsonLd, proof, {
+		documentLoader: honestLoader,
+		contextLoader: mockDocumentLoader
+	}), Multikey);
+	assertEquals(await verifyObject(Create, jsonLd, {
+		documentLoader: honestLoader,
+		contextLoader: mockDocumentLoader
+	}), null);
+});
+test("verifyPortableObjectProof() verifies objects fetched through gateways", async (t) => {
+	const objectId = `ap://${portableDid}/objects/gateway`;
+	const gatewayUrl = `https://gateway.example/.well-known/apgateway/${portableDid}/objects/gateway`;
+	const signedNote = await signPortableJsonLd({
+		"@context": portableContext,
+		id: objectId,
+		type: "Note",
+		attributedTo: `ap://${portableDid}/actor`,
+		content: "Hello from a gateway"
+	});
+	const getObject = async (document, object = objectId, url = gatewayUrl) => {
+		return await (await Create.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			id: `ap://${portableDid}/activities/1`,
+			object
+		}, { contextLoader: mockDocumentLoader })).getObject({
+			documentLoader: async (requestUrl) => {
+				if (requestUrl !== url) throw new Error(`Unexpected URL: ${requestUrl}`);
+				return {
+					contextUrl: null,
+					documentUrl: requestUrl,
+					document
+				};
+			},
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gateway.example"],
+			verifyPortableObject: verifyPortableObjectProof
+		});
+	};
+	await t.step("a properly signed object", async () => {
+		const object = await getObject(signedNote);
+		assertInstanceOf(object, Note);
+		assertEquals(object.content, "Hello from a gateway");
+	});
+	await t.step("a tampered object", async () => {
+		assertEquals(await getObject({
+			...signedNote,
+			content: "Tampered"
+		}), null);
+	});
+	await t.step("an object without a proof", async () => {
+		const { proof: _, ...unsigned } = signedNote;
+		assertEquals(await getObject(unsigned), null);
+	});
+	await t.step("an object without an ID", async () => {
+		const withoutId = await signPortableJsonLd({
+			"@context": portableContext,
+			type: "Note",
+			content: "Hello from a gateway"
+		});
+		assertEquals(await getObject(withoutId), null);
+	});
+	await t.step("another object of the same DID", async () => {
+		assertEquals(await getObject(signedNote, `ap://${portableDid}/objects/other`, `https://gateway.example/.well-known/apgateway/${portableDid}/objects/other`), null);
+	});
+	await t.step("an object signed by another DID", async () => {
+		const otherDid = await exportDidKey(await crypto.subtle.importKey("jwk", {
+			kty: "OKP",
+			crv: "Ed25519",
+			x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+			key_ops: ["verify"],
+			ext: true
+		}, "Ed25519", true, ["verify"]));
+		const otherObjectId = `ap://${otherDid}/objects/gateway`;
+		const otherGatewayUrl = `https://gateway.example/.well-known/apgateway/${otherDid}/objects/gateway`;
+		const spoofed = await signPortableJsonLd({
+			"@context": portableContext,
+			id: otherObjectId,
+			type: "Note",
+			content: "Spoofed"
+		});
+		assertEquals(await getObject(spoofed, otherObjectId, otherGatewayUrl), null);
+		const forged = await signPortableJsonLd({
+			"@context": portableContext,
+			id: objectId,
+			type: "Note",
+			content: "Forged"
+		}, { privateKey: fep8b32TestVectorPrivateKey });
+		assertEquals(await getObject(forged), null);
+	});
+});
+test("getAuthenticatedDocumentLoader() signs portable object requests to gateways", {
+	sanitizeResources: false,
+	sanitizeOps: false
+}, async () => {
+	const objectId = `ap://${portableDid}/objects/private`;
+	const signedNote = await signPortableJsonLd({
+		"@context": portableContext,
+		id: objectId,
+		type: "Note",
+		attributedTo: `ap://${portableDid}/actor`,
+		content: "Followers only"
+	});
+	esm_default.spyGlobal();
+	let signed = false;
+	let accept = null;
+	esm_default.get(`https://example.com/.well-known/apgateway/${portableDid}/objects/private`, async (cl) => {
+		accept = cl.request.headers.get("Accept");
+		signed = await verifyRequest(cl.request, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime: Temporal.Now.instant()
+		}) != null;
+		if (!signed) return new Response(null, { status: 401 });
+		return new Response(JSON.stringify(signedNote), { headers: { "Content-Type": "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"" } });
+	});
+	try {
+		const object = await (await Create.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			id: `ap://${portableDid}/activities/1`,
+			object: objectId
+		}, { contextLoader: mockDocumentLoader })).getObject({
+			documentLoader: getAuthenticatedDocumentLoader({
+				keyId: new URL("https://example.com/key2"),
+				privateKey: rsaPrivateKey2
+			}),
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://example.com"],
+			verifyPortableObject: verifyPortableObjectProof
+		});
+		assertInstanceOf(object, Note);
+		assertEquals(object.content, "Followers only");
+		assert(signed);
+		assertEquals(accept, "application/activity+json, application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"");
+	} finally {
+		esm_default.hardReset();
+	}
+});
 //#endregion
 export {};