@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

package/dist/sig/owner.d.ts

@@ -0,0 +1,74 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { DocumentLoader } from "../runtime/docloader.js";
+import { Activity$1 as Activity, CryptographicKey$1 as CryptographicKey } from "../vocab/vocab.js";
+import { Actor } from "../vocab/actor.js";
+import { exportJwk$1 as exportJwk, generateCryptoKeyPair$1 as generateCryptoKeyPair, importJwk$1 as importJwk } from "./key.js";
+import { TracerProvider } from "@opentelemetry/api";
+
+//#region sig/owner.d.ts
+/**
+* Options for {@link doesActorOwnKey}.
+* @since 0.8.0
+*/
+/**
+ * Options for {@link doesActorOwnKey}.
+ * @since 0.8.0
+ */
+interface DoesActorOwnKeyOptions {
+  /**
+   * The document loader to use for fetching the actor.
+   */
+  documentLoader?: DocumentLoader;
+  /**
+   * The context loader to use for JSON-LD context retrieval.
+   */
+  contextLoader?: DocumentLoader;
+  /**
+   * The OpenTelemetry tracer provider to use for tracing.  If omitted,
+   * the global tracer provider is used.
+   * @since 1.3.0
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Checks if the actor of the given activity owns the specified key.
+ * @param activity The activity to check.
+ * @param key The public key to check.
+ * @param options Options for checking the key ownership.
+ * @returns Whether the actor is the owner of the key.
+ */
+declare function doesActorOwnKey(activity: Activity, key: CryptographicKey, options: DoesActorOwnKeyOptions): Promise<boolean>;
+/**
+ * Options for {@link getKeyOwner}.
+ * @since 0.8.0
+ */
+interface GetKeyOwnerOptions {
+  /**
+   * The document loader to use for fetching the key and its owner.
+   */
+  documentLoader?: DocumentLoader;
+  /**
+   * The context loader to use for JSON-LD context retrieval.
+   */
+  contextLoader?: DocumentLoader;
+  /**
+   * The OpenTelemetry tracer provider to use for tracing.  If omitted,
+   * the global tracer provider is used.
+   * @since 1.3.0
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Gets the actor that owns the specified key.  Returns `null` if the key has no
+ * known owner.
+ *
+ * @param keyId The ID of the key to check, or the key itself.
+ * @param options Options for getting the key owner.
+ * @returns The actor that owns the key, or `null` if the key has no known
+ *          owner.
+ * @since 0.7.0
+ */
+declare function getKeyOwner(keyId: URL | CryptographicKey, options: GetKeyOwnerOptions): Promise<Actor | null>;
+//#endregion
+export { DoesActorOwnKeyOptions, GetKeyOwnerOptions, doesActorOwnKey as doesActorOwnKey$1, getKeyOwner as getKeyOwner$1 };

package/dist/sig/owner.js

@@ -0,0 +1,89 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { getDocumentLoader } from "../runtime/docloader.js";
+import { CryptographicKey, Object as Object$1 } from "../vocab/vocab.js";
+import { isActor } from "../vocab/actor.js";
+import { exportJwk, generateCryptoKeyPair, importJwk } from "./key.js";
+import { trace } from "@opentelemetry/api";
+
+//#region sig/owner.ts
+/**
+* Checks if the actor of the given activity owns the specified key.
+* @param activity The activity to check.
+* @param key The public key to check.
+* @param options Options for checking the key ownership.
+* @returns Whether the actor is the owner of the key.
+*/
+async function doesActorOwnKey(activity, key, options) {
+	if (key.ownerId != null) return key.ownerId.href === activity.actorId?.href;
+	const actor = await activity.getActor(options);
+	if (actor == null || !isActor(actor)) return false;
+	for (const publicKeyId of actor.publicKeyIds) if (key.id != null && publicKeyId.href === key.id.href) return true;
+	return false;
+}
+/**
+* Gets the actor that owns the specified key.  Returns `null` if the key has no
+* known owner.
+*
+* @param keyId The ID of the key to check, or the key itself.
+* @param options Options for getting the key owner.
+* @returns The actor that owns the key, or `null` if the key has no known
+*          owner.
+* @since 0.7.0
+*/
+async function getKeyOwner(keyId, options) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const documentLoader = options.documentLoader ?? getDocumentLoader();
+	const contextLoader = options.contextLoader ?? getDocumentLoader();
+	let object;
+	if (keyId instanceof CryptographicKey) {
+		object = keyId;
+		if (object.id == null) return null;
+		keyId = object.id;
+	} else {
+		let keyDoc;
+		try {
+			const { document } = await documentLoader(keyId.href);
+			keyDoc = document;
+		} catch (_) {
+			return null;
+		}
+		try {
+			object = await Object$1.fromJsonLd(keyDoc, {
+				documentLoader,
+				contextLoader,
+				tracerProvider
+			});
+		} catch (e) {
+			if (!(e instanceof TypeError)) throw e;
+			try {
+				object = await CryptographicKey.fromJsonLd(keyDoc, {
+					documentLoader,
+					contextLoader,
+					tracerProvider
+				});
+			} catch (e$1) {
+				if (e$1 instanceof TypeError) return null;
+				throw e$1;
+			}
+		}
+	}
+	let owner = null;
+	if (object instanceof CryptographicKey) {
+		if (object.ownerId == null) return null;
+		owner = await object.getOwner({
+			documentLoader,
+			contextLoader,
+			tracerProvider
+		});
+	} else if (isActor(object)) owner = object;
+	else return null;
+	if (owner == null) return null;
+	for (const kid of owner.publicKeyIds) if (kid.href === keyId.href) return owner;
+	return null;
+}
+
+//#endregion
+export { doesActorOwnKey, getKeyOwner };

package/dist/sig/owner.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/sig/owner.test.js

@@ -0,0 +1,45 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Create } from "../vocab/vocab.js";
+import { doesActorOwnKey, getKeyOwner } from "./owner.js";
+import { lookupObject } from "../vocab/lookup.js";
+import { assert } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { assertFalse } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js";
+import { mockDocumentLoader } from "../testing/docloader.js";
+import { rsaPublicKey1, rsaPublicKey2 } from "../testing/keys.js";
+
+//#region sig/owner.test.ts
+test("doesActorOwnKey()", async () => {
+	const options = {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	const activity = new Create({ actor: new URL("https://example.com/person") });
+	assert(await doesActorOwnKey(activity, rsaPublicKey1, options));
+	assert(await doesActorOwnKey(activity, rsaPublicKey2, options));
+	const activity2 = new Create({ actor: new URL("https://example.com/hong-gildong") });
+	assertFalse(await doesActorOwnKey(activity2, rsaPublicKey1, options));
+	assertFalse(await doesActorOwnKey(activity2, rsaPublicKey2, options));
+});
+test("getKeyOwner()", async () => {
+	const options = {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	const owner = await getKeyOwner(new URL("https://example.com/users/handle#main-key"), options);
+	assertEquals(owner, await lookupObject("https://example.com/users/handle", options));
+	const owner2 = await getKeyOwner(new URL("https://example.com/key"), options);
+	assertEquals(owner2, await lookupObject("https://example.com/person", options));
+	const owner3 = await getKeyOwner(rsaPublicKey1, options);
+	assertEquals(owner3, owner2);
+	const noOwner = await getKeyOwner(new URL("https://example.com/key2"), options);
+	assertEquals(noOwner, null);
+	const noOwner2 = await getKeyOwner(new URL("https://example.com/object"), options);
+	assertEquals(noOwner2, null);
+});
+
+//#endregion

package/dist/sig/proof.d.ts

@@ -0,0 +1,134 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { DocumentLoader } from "../runtime/docloader.js";
+import { DataIntegrityProof$1 as DataIntegrityProof, Multikey$1 as Multikey, Object$1 } from "../vocab/vocab.js";
+import { KeyCache } from "./key.js";
+import { TracerProvider } from "@opentelemetry/api";
+
+//#region sig/proof.d.ts
+/**
+* Options for {@link createProof}.
+* @since 0.10.0
+*/
+/**
+ * Options for {@link createProof}.
+ * @since 0.10.0
+ */
+interface CreateProofOptions {
+  /**
+   * The context loader for loading remote JSON-LD contexts.
+   */
+  contextLoader?: DocumentLoader;
+  /**
+   * The JSON-LD context to use for serializing the object to sign.
+   */
+  context?: string | Record<string, string> | (string | Record<string, string>)[];
+  /**
+   * The time when the proof was created.  If not specified, the current time
+   * will be used.
+   */
+  created?: Temporal.Instant;
+}
+/**
+ * Creates a proof for the given object.
+ * @param object The object to create a proof for.
+ * @param privateKey The private key to sign the proof with.
+ * @param keyId The key ID to use in the proof. It will be used by the verifier.
+ * @param options Additional options.  See also {@link CreateProofOptions}.
+ * @returns The created proof.
+ * @throws {TypeError} If the private key is invalid or unsupported.
+ * @since 0.10.0
+ */
+declare function createProof(object: Object$1, privateKey: CryptoKey, keyId: URL, {
+  contextLoader,
+  context,
+  created
+}?: CreateProofOptions): Promise<DataIntegrityProof>;
+/**
+ * Options for {@link signObject}.
+ * @since 0.10.0
+ */
+interface SignObjectOptions extends CreateProofOptions {
+  /**
+   * The document loader for loading remote JSON-LD documents.
+   */
+  documentLoader?: DocumentLoader;
+  /**
+   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
+   * is used.
+   * @since 1.3.0
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Signs the given object with the private key and returns the signed object.
+ * @param object The object to create a proof for.
+ * @param privateKey The private key to sign the proof with.
+ * @param keyId The key ID to use in the proof. It will be used by the verifier.
+ * @param options Additional options.  See also {@link SignObjectOptions}.
+ * @returns The signed object.
+ * @throws {TypeError} If the private key is invalid or unsupported.
+ * @since 0.10.0
+ */
+declare function signObject<T extends Object$1>(object: T, privateKey: CryptoKey, keyId: URL, options?: SignObjectOptions): Promise<T>;
+/**
+ * Options for {@link verifyProof}.
+ * @since 0.10.0
+ */
+interface VerifyProofOptions {
+  /**
+   * The context loader for loading remote JSON-LD contexts.
+   */
+  contextLoader?: DocumentLoader;
+  /**
+   * The document loader for loading remote JSON-LD documents.
+   */
+  documentLoader?: DocumentLoader;
+  /**
+   * The key cache to use for caching public keys.
+   * @since 0.12.0
+   */
+  keyCache?: KeyCache;
+  /**
+   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
+   * is used.
+   * @since 1.3.0
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Verifies the given proof for the object.
+ * @param jsonLd The JSON-LD object to verify the proof for.  If it contains
+ *               any proofs, they will be ignored.
+ * @param proof The proof to verify.
+ * @param options Additional options.  See also {@link VerifyProofOptions}.
+ * @returns The public key that was used to sign the proof, or `null` if the
+ *          proof is invalid.
+ * @since 0.10.0
+ */
+declare function verifyProof(jsonLd: unknown, proof: DataIntegrityProof, options?: VerifyProofOptions): Promise<Multikey | null>;
+/**
+ * Options for {@link verifyObject}.
+ * @since 0.10.0
+ */
+interface VerifyObjectOptions extends VerifyProofOptions {}
+/**
+ * Verifies the given object.  It will verify all the proofs in the object,
+ * and succeed only if all the proofs are valid and all attributions and
+ * actors are authenticated by the proofs.
+ * @typeParam T The type of the object to verify.
+ * @param cls The class of the object to verify.  It must be a subclass of
+ *            the {@link Object}.
+ * @param jsonLd The JSON-LD object to verify.  It's assumed that the object
+ *               is a compacted JSON-LD representation of a `T` with `@context`.
+ * @param options Additional options.  See also {@link VerifyObjectOptions}.
+ * @returns The object if it's verified, or `null` if it's not.
+ * @throws {TypeError} If the object is invalid or unsupported.
+ * @since 0.10.0
+ */
+declare function verifyObject<T extends Object$1>(cls: (new (...args: any[]) => T) & {
+  fromJsonLd(jsonLd: unknown, options: VerifyObjectOptions): Promise<T>;
+}, jsonLd: unknown, options?: VerifyObjectOptions): Promise<T | null>;
+
+//#endregion
+export { CreateProofOptions, SignObjectOptions, VerifyObjectOptions, VerifyProofOptions, createProof as createProof$1, signObject as signObject$1, verifyObject as verifyObject$1, verifyProof as verifyProof$1 };

package/dist/sig/proof.js

@@ -0,0 +1,262 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { deno_default } from "../deno.js";
+import { getTypeId } from "../vocab/type.js";
+import { Activity, DataIntegrityProof, Multikey } from "../vocab/vocab.js";
+import { fetchKey, validateCryptoKey } from "./key.js";
+import { getLogger } from "@logtape/logtape";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { encodeHex } from "byte-encodings/hex";
+import serialize from "json-canon";
+
+//#region sig/proof.ts
+const logger = getLogger([
+	"fedify",
+	"sig",
+	"proof"
+]);
+/**
+* Creates a proof for the given object.
+* @param object The object to create a proof for.
+* @param privateKey The private key to sign the proof with.
+* @param keyId The key ID to use in the proof. It will be used by the verifier.
+* @param options Additional options.  See also {@link CreateProofOptions}.
+* @returns The created proof.
+* @throws {TypeError} If the private key is invalid or unsupported.
+* @since 0.10.0
+*/
+async function createProof(object, privateKey, keyId, { contextLoader, context: context$1, created } = {}) {
+	validateCryptoKey(privateKey, "private");
+	if (privateKey.algorithm.name !== "Ed25519") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
+	const objectWithoutProofs = object.clone({ proofs: [] });
+	const compactMsg = await objectWithoutProofs.toJsonLd({
+		format: "compact",
+		contextLoader,
+		context: context$1
+	});
+	const msgCanon = serialize(compactMsg);
+	const encoder = new TextEncoder();
+	const msgBytes = encoder.encode(msgCanon);
+	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
+	created ??= Temporal.Now.instant();
+	const proofConfig = {
+		"@context": compactMsg["@context"],
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod: keyId.href,
+		proofPurpose: "assertionMethod",
+		created: created.toString()
+	};
+	const proofCanon = serialize(proofConfig);
+	const proofBytes = encoder.encode(proofCanon);
+	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
+	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
+	digest.set(new Uint8Array(proofDigest), 0);
+	digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
+	const sig = await crypto.subtle.sign("Ed25519", privateKey, digest);
+	return new DataIntegrityProof({
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod: keyId,
+		proofPurpose: "assertionMethod",
+		created: created ?? Temporal.Now.instant(),
+		proofValue: new Uint8Array(sig)
+	});
+}
+/**
+* Signs the given object with the private key and returns the signed object.
+* @param object The object to create a proof for.
+* @param privateKey The private key to sign the proof with.
+* @param keyId The key ID to use in the proof. It will be used by the verifier.
+* @param options Additional options.  See also {@link SignObjectOptions}.
+* @returns The signed object.
+* @throws {TypeError} If the private key is invalid or unsupported.
+* @since 0.10.0
+*/
+async function signObject(object, privateKey, keyId, options = {}) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	return await tracer.startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": getTypeId(object).href } }, async (span) => {
+		try {
+			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
+			const existingProofs = [];
+			for await (const proof$1 of object.getProofs(options)) existingProofs.push(proof$1);
+			const proof = await createProof(object, privateKey, keyId, options);
+			if (span.isRecording()) {
+				if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
+				if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
+				if (proof.proofValue != null) span.setAttribute("object_integrity_proofs.signature", encodeHex(proof.proofValue));
+			}
+			return object.clone({ proofs: [...existingProofs, proof] });
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+/**
+* Verifies the given proof for the object.
+* @param jsonLd The JSON-LD object to verify the proof for.  If it contains
+*               any proofs, they will be ignored.
+* @param proof The proof to verify.
+* @param options Additional options.  See also {@link VerifyProofOptions}.
+* @returns The public key that was used to sign the proof, or `null` if the
+*          proof is invalid.
+* @since 0.10.0
+*/
+async function verifyProof(jsonLd, proof, options = {}) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	return await tracer.startActiveSpan("object_integrity_proofs.verify", async (span) => {
+		if (span.isRecording()) {
+			if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
+			if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
+			if (proof.proofValue != null) span.setAttribute("object_integrity_proofs.signature", encodeHex(proof.proofValue));
+		}
+		try {
+			const key = await verifyProofInternal(jsonLd, proof, options);
+			if (key == null) span.setStatus({ code: SpanStatusCode.ERROR });
+			return key;
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function verifyProofInternal(jsonLd, proof, options) {
+	if (typeof jsonLd !== "object" || proof.cryptosuite !== "eddsa-jcs-2022" || proof.verificationMethodId == null || proof.proofPurpose !== "assertionMethod" || proof.proofValue == null || proof.created == null) return null;
+	const publicKeyPromise = fetchKey(proof.verificationMethodId, Multikey, options);
+	const proofConfig = {
+		"@context": jsonLd["@context"],
+		type: "DataIntegrityProof",
+		cryptosuite: proof.cryptosuite,
+		verificationMethod: proof.verificationMethodId.href,
+		proofPurpose: proof.proofPurpose,
+		created: proof.created.toString()
+	};
+	const proofCanon = serialize(proofConfig);
+	const encoder = new TextEncoder();
+	const proofBytes = encoder.encode(proofCanon);
+	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
+	const msg = { ...jsonLd };
+	if ("proof" in msg) delete msg.proof;
+	const msgCanon = serialize(msg);
+	const msgBytes = encoder.encode(msgCanon);
+	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
+	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
+	digest.set(new Uint8Array(proofDigest), 0);
+	digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
+	let fetchedKey;
+	try {
+		fetchedKey = await publicKeyPromise;
+	} catch (error) {
+		logger.debug("Failed to get the key (verificationMethod) for the proof:\n{proof}", {
+			proof,
+			keyId: proof.verificationMethodId.href,
+			error
+		});
+		return null;
+	}
+	const publicKey = fetchedKey.key;
+	if (publicKey == null) {
+		logger.debug("Failed to get the key (verificationMethod) for the proof:\n{proof}", {
+			proof,
+			keyId: proof.verificationMethodId.href
+		});
+		return null;
+	}
+	if (publicKey.publicKey.algorithm.name !== "Ed25519") {
+		if (fetchedKey.cached) {
+			logger.debug("The cached key (verificationMethod) for the proof is not a valid Ed25519 key:\n{keyId}; retrying with the freshly fetched key...", {
+				proof,
+				keyId: proof.verificationMethodId.href
+			});
+			return await verifyProof(jsonLd, proof, {
+				...options,
+				keyCache: {
+					get: () => Promise.resolve(null),
+					set: async (keyId, key) => await options.keyCache?.set(keyId, key)
+				}
+			});
+		}
+		logger.debug("The fetched key (verificationMethod) for the proof is not a valid Ed25519 key:\n{keyId}", {
+			proof,
+			keyId: proof.verificationMethodId.href
+		});
+		return null;
+	}
+	const verified = await crypto.subtle.verify("Ed25519", publicKey.publicKey, proof.proofValue, digest);
+	if (!verified) {
+		if (fetchedKey.cached) {
+			logger.debug("Failed to verify the proof with the cached key {keyId}; retrying with the freshly fetched key...", {
+				keyId: proof.verificationMethodId.href,
+				proof
+			});
+			return await verifyProof(jsonLd, proof, {
+				...options,
+				keyCache: {
+					get: () => Promise.resolve(void 0),
+					set: async (keyId, key) => await options.keyCache?.set(keyId, key)
+				}
+			});
+		}
+		logger.debug("Failed to verify the proof with the fetched key {keyId}:\n{proof}", {
+			keyId: proof.verificationMethodId.href,
+			proof
+		});
+		return null;
+	}
+	return publicKey;
+}
+/**
+* Verifies the given object.  It will verify all the proofs in the object,
+* and succeed only if all the proofs are valid and all attributions and
+* actors are authenticated by the proofs.
+* @typeParam T The type of the object to verify.
+* @param cls The class of the object to verify.  It must be a subclass of
+*            the {@link Object}.
+* @param jsonLd The JSON-LD object to verify.  It's assumed that the object
+*               is a compacted JSON-LD representation of a `T` with `@context`.
+* @param options Additional options.  See also {@link VerifyObjectOptions}.
+* @returns The object if it's verified, or `null` if it's not.
+* @throws {TypeError} If the object is invalid or unsupported.
+* @since 0.10.0
+*/
+async function verifyObject(cls, jsonLd, options = {}) {
+	const logger$1 = getLogger([
+		"fedify",
+		"sig",
+		"proof"
+	]);
+	const object = await cls.fromJsonLd(jsonLd, options);
+	const attributions = new Set(object.attributionIds.map((uri) => uri.href));
+	if (object instanceof Activity) for (const uri of object.actorIds) attributions.add(uri.href);
+	for await (const proof of object.getProofs(options)) {
+		const key = await verifyProof(jsonLd, proof, options);
+		if (key === null) return null;
+		if (key.controllerId == null) {
+			logger$1.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
+			continue;
+		}
+		attributions.delete(key.controllerId.href);
+	}
+	if (attributions.size > 0) {
+		logger$1.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
+		return null;
+	}
+	return object;
+}
+
+//#endregion
+export { createProof, signObject, verifyObject, verifyProof };

package/dist/sig/proof.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";