@oma3/omatrust 0.1.0-alpha.11 → 0.1.0-alpha.12

package/dist/reputation/index.cjs

@@ -228,6 +228,145 @@ function parseCaip10(input) {
   }
   return { namespace, reference, address };
 }
+var VALID_KTY = /* @__PURE__ */ new Set(["EC", "OKP", "RSA"]);
+var PRIVATE_KEY_FIELDS = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth"]);
+var REQUIRED_PUBLIC_FIELDS = {
+  EC: ["crv", "x", "y"],
+  OKP: ["crv", "x"],
+  RSA: ["n", "e"]
+};
+function validatePublicJwk(jwk) {
+  if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) {
+    return { valid: false, error: "JWK must be a non-null object" };
+  }
+  const obj = jwk;
+  const kty = obj.kty;
+  if (typeof kty !== "string" || !VALID_KTY.has(kty)) {
+    return {
+      valid: false,
+      error: `Invalid or missing kty (must be one of: ${[...VALID_KTY].join(", ")})`
+    };
+  }
+  for (const field of PRIVATE_KEY_FIELDS) {
+    if (field in obj) {
+      return {
+        valid: false,
+        error: `JWK contains private key field "${field}" \u2014 only public keys are allowed`
+      };
+    }
+  }
+  const required = REQUIRED_PUBLIC_FIELDS[kty];
+  if (required) {
+    for (const field of required) {
+      if (!(field in obj) || obj[field] === void 0 || obj[field] === null || obj[field] === "") {
+        return {
+          valid: false,
+          error: `Missing required public key field "${field}" for kty="${kty}"`
+        };
+      }
+    }
+  }
+  return { valid: true };
+}
+function canonicalizeJwkJson(jwk) {
+  const sorted = Object.keys(jwk).sort();
+  const obj = {};
+  for (const key of sorted) {
+    obj[key] = jwk[key];
+  }
+  return JSON.stringify(obj);
+}
+function jwkToDidJwk(jwk) {
+  assertObject(jwk, "jwk", "INVALID_JWK");
+  const validation = validatePublicJwk(jwk);
+  if (!validation.valid) {
+    throw new OmaTrustError("INVALID_JWK", validation.error ?? "Invalid public JWK", { jwk });
+  }
+  const canonical = canonicalizeJwkJson(jwk);
+  const encoded = jose.base64url.encode(new TextEncoder().encode(canonical));
+  return `did:jwk:${encoded}`;
+}
+function didJwkToJwk(didJwk) {
+  if (typeof didJwk !== "string" || !didJwk.startsWith("did:jwk:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected a did:jwk DID", { input: didJwk });
+  }
+  const parts = didJwk.split(":");
+  if (parts.length !== 3) {
+    throw new OmaTrustError("INVALID_DID", "did:jwk must have exactly 3 colon-separated parts", {
+      input: didJwk
+    });
+  }
+  const encoded = parts[2];
+  if (!encoded || encoded.length === 0) {
+    throw new OmaTrustError("INVALID_DID", "Missing base64url-encoded JWK identifier", {
+      input: didJwk
+    });
+  }
+  let decoded;
+  try {
+    const bytes = jose.base64url.decode(encoded);
+    decoded = new TextDecoder().decode(bytes);
+  } catch {
+    throw new OmaTrustError("INVALID_DID", "Failed to base64url-decode did:jwk identifier", {
+      input: didJwk
+    });
+  }
+  let jwk;
+  try {
+    jwk = JSON.parse(decoded);
+  } catch {
+    throw new OmaTrustError("INVALID_DID", "Decoded did:jwk identifier is not valid JSON", {
+      input: didJwk
+    });
+  }
+  if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) {
+    throw new OmaTrustError("INVALID_DID", "Decoded did:jwk must be a JSON object", {
+      input: didJwk
+    });
+  }
+  const validation = validatePublicJwk(jwk);
+  if (!validation.valid) {
+    throw new OmaTrustError("INVALID_DID", validation.error ?? "Invalid public JWK in did:jwk", {
+      input: didJwk
+    });
+  }
+  return jwk;
+}
+function extractPublicKeyFields(jwk) {
+  const result = {};
+  const metadataFields = /* @__PURE__ */ new Set(["kid", "use", "key_ops", "alg", "ext"]);
+  for (const [key, value] of Object.entries(jwk)) {
+    if (PRIVATE_KEY_FIELDS.has(key)) continue;
+    if (metadataFields.has(key)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function publicJwkEquals(a, b) {
+  assertObject(a, "a", "INVALID_JWK");
+  assertObject(b, "b", "INVALID_JWK");
+  const aObj = a;
+  const bObj = b;
+  for (const field of PRIVATE_KEY_FIELDS) {
+    if (field in aObj) {
+      throw new OmaTrustError(
+        "INVALID_JWK",
+        `First JWK contains private key field "${field}"`,
+        { field }
+      );
+    }
+    if (field in bObj) {
+      throw new OmaTrustError(
+        "INVALID_JWK",
+        `Second JWK contains private key field "${field}"`,
+        { field }
+      );
+    }
+  }
+  const aPublic = extractPublicKeyFields(aObj);
+  const bPublic = extractPublicKeyFields(bObj);
+  return canonicalizeJwkJson(aPublic) === canonicalizeJwkJson(bPublic);
+}
 
 // src/identity/did.ts
 var DID_REGEX = /^did:[a-z0-9]+:.+$/i;
@@ -299,7 +438,7 @@ function normalizeDidKey(input) {
 }
 function normalizeDid(input) {
   assertString(input, "input", "INVALID_DID");
-  const trimmed = input.trim();
+  const trimmed = input.trim().split("#")[0];
   if (!trimmed.startsWith("did:")) {
     return normalizeDidWeb(trimmed);
   }
@@ -460,6 +599,10 @@ function validateDidJwk(did) {
       error: "DID must reference a public key \u2014 private key component (d) is not allowed"
     };
   }
+  const jwkValidation = validatePublicJwk(jwk);
+  if (!jwkValidation.valid) {
+    return { valid: false, method: "jwk", error: jwkValidation.error };
+  }
   return { valid: true, method: "jwk" };
 }
 function normalizeDidJwk(input) {
@@ -1128,145 +1271,6 @@ function getExplorerTxUrl(chainId, txHash) {
 function getExplorerAddressUrl(chainId, address) {
   return `${getConfig(chainId).explorer}/address/${address}`;
 }
-var VALID_KTY = /* @__PURE__ */ new Set(["EC", "OKP", "RSA"]);
-var PRIVATE_KEY_FIELDS = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth"]);
-var REQUIRED_PUBLIC_FIELDS = {
-  EC: ["crv", "x", "y"],
-  OKP: ["crv", "x"],
-  RSA: ["n", "e"]
-};
-function validatePublicJwk(jwk) {
-  if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) {
-    return { valid: false, error: "JWK must be a non-null object" };
-  }
-  const obj = jwk;
-  const kty = obj.kty;
-  if (typeof kty !== "string" || !VALID_KTY.has(kty)) {
-    return {
-      valid: false,
-      error: `Invalid or missing kty (must be one of: ${[...VALID_KTY].join(", ")})`
-    };
-  }
-  for (const field of PRIVATE_KEY_FIELDS) {
-    if (field in obj) {
-      return {
-        valid: false,
-        error: `JWK contains private key field "${field}" \u2014 only public keys are allowed`
-      };
-    }
-  }
-  const required = REQUIRED_PUBLIC_FIELDS[kty];
-  if (required) {
-    for (const field of required) {
-      if (!(field in obj) || obj[field] === void 0 || obj[field] === null || obj[field] === "") {
-        return {
-          valid: false,
-          error: `Missing required public key field "${field}" for kty="${kty}"`
-        };
-      }
-    }
-  }
-  return { valid: true };
-}
-function canonicalizeJwkJson(jwk) {
-  const sorted = Object.keys(jwk).sort();
-  const obj = {};
-  for (const key of sorted) {
-    obj[key] = jwk[key];
-  }
-  return JSON.stringify(obj);
-}
-function jwkToDidJwk(jwk) {
-  assertObject(jwk, "jwk", "INVALID_JWK");
-  const validation = validatePublicJwk(jwk);
-  if (!validation.valid) {
-    throw new OmaTrustError("INVALID_JWK", validation.error ?? "Invalid public JWK", { jwk });
-  }
-  const canonical = canonicalizeJwkJson(jwk);
-  const encoded = jose.base64url.encode(new TextEncoder().encode(canonical));
-  return `did:jwk:${encoded}`;
-}
-function didJwkToJwk(didJwk) {
-  if (typeof didJwk !== "string" || !didJwk.startsWith("did:jwk:")) {
-    throw new OmaTrustError("INVALID_DID", "Expected a did:jwk DID", { input: didJwk });
-  }
-  const parts = didJwk.split(":");
-  if (parts.length !== 3) {
-    throw new OmaTrustError("INVALID_DID", "did:jwk must have exactly 3 colon-separated parts", {
-      input: didJwk
-    });
-  }
-  const encoded = parts[2];
-  if (!encoded || encoded.length === 0) {
-    throw new OmaTrustError("INVALID_DID", "Missing base64url-encoded JWK identifier", {
-      input: didJwk
-    });
-  }
-  let decoded;
-  try {
-    const bytes = jose.base64url.decode(encoded);
-    decoded = new TextDecoder().decode(bytes);
-  } catch {
-    throw new OmaTrustError("INVALID_DID", "Failed to base64url-decode did:jwk identifier", {
-      input: didJwk
-    });
-  }
-  let jwk;
-  try {
-    jwk = JSON.parse(decoded);
-  } catch {
-    throw new OmaTrustError("INVALID_DID", "Decoded did:jwk identifier is not valid JSON", {
-      input: didJwk
-    });
-  }
-  if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) {
-    throw new OmaTrustError("INVALID_DID", "Decoded did:jwk must be a JSON object", {
-      input: didJwk
-    });
-  }
-  const validation = validatePublicJwk(jwk);
-  if (!validation.valid) {
-    throw new OmaTrustError("INVALID_DID", validation.error ?? "Invalid public JWK in did:jwk", {
-      input: didJwk
-    });
-  }
-  return jwk;
-}
-function extractPublicKeyFields(jwk) {
-  const result = {};
-  const metadataFields = /* @__PURE__ */ new Set(["kid", "use", "key_ops", "alg", "ext"]);
-  for (const [key, value] of Object.entries(jwk)) {
-    if (PRIVATE_KEY_FIELDS.has(key)) continue;
-    if (metadataFields.has(key)) continue;
-    result[key] = value;
-  }
-  return result;
-}
-function publicJwkEquals(a, b) {
-  assertObject(a, "a", "INVALID_JWK");
-  assertObject(b, "b", "INVALID_JWK");
-  const aObj = a;
-  const bObj = b;
-  for (const field of PRIVATE_KEY_FIELDS) {
-    if (field in aObj) {
-      throw new OmaTrustError(
-        "INVALID_JWK",
-        `First JWK contains private key field "${field}"`,
-        { field }
-      );
-    }
-    if (field in bObj) {
-      throw new OmaTrustError(
-        "INVALID_JWK",
-        `Second JWK contains private key field "${field}"`,
-        { field }
-      );
-    }
-  }
-  const aPublic = extractPublicKeyFields(aObj);
-  const bPublic = extractPublicKeyFields(bObj);
-  return canonicalizeJwkJson(aPublic) === canonicalizeJwkJson(bPublic);
-}
 
 // src/shared/did-document.ts
 async function fetchDidDocument(domain) {
@@ -2868,6 +2872,42 @@ function createX402OfferProof(offer) {
   };
 }
 
+// src/reputation/proof/x402-verify.ts
+async function verifyX402Artifact(artifact, options) {
+  if (!artifact || typeof artifact !== "object") {
+    return {
+      valid: false,
+      error: { code: "INVALID_ARTIFACT", message: "Artifact must be a non-null object" }
+    };
+  }
+  const format = artifact.format;
+  switch (format) {
+    case "jws": {
+      const jwsArtifact = artifact;
+      const jwsOptions = options.resolveOptions ? { resolveOptions: options.resolveOptions } : void 0;
+      if (options.artifactType === "offer") {
+        return verifyX402JwsOffer(jwsArtifact, jwsOptions);
+      }
+      return verifyX402JwsReceipt(jwsArtifact, jwsOptions);
+    }
+    case "eip712": {
+      const eip712Artifact = artifact;
+      if (options.artifactType === "offer") {
+        return verifyX402Eip712Offer(eip712Artifact);
+      }
+      return verifyX402Eip712Receipt(eip712Artifact);
+    }
+    default:
+      return {
+        valid: false,
+        error: {
+          code: "UNSUPPORTED_FORMAT",
+          message: `Unsupported x402 artifact format: "${format}"`
+        }
+      };
+  }
+}
+
 // src/reputation/proof/evidence-pointer.ts
 function createEvidencePointerProof(url) {
   if (!url || typeof url !== "string") {
@@ -3153,6 +3193,300 @@ async function verifySubjectOwnership(params) {
     subjectDid
   });
 }
+function extractEip712Signer(proof) {
+  const { domain, message, signature } = proof.proofObject;
+  const typedData = {
+    domain,
+    types: {
+      OmaTrustProof: [
+        { name: "signer", type: "address" },
+        { name: "authorizedEntity", type: "string" },
+        { name: "signingPurpose", type: "string" },
+        { name: "creationTimestamp", type: "uint256" },
+        { name: "expirationTimestamp", type: "uint256" },
+        { name: "randomValue", type: "bytes32" },
+        { name: "statement", type: "string" }
+      ]
+    },
+    message
+  };
+  try {
+    const result = verifyEip712Signature(typedData, signature);
+    return result.valid && result.signer ? result.signer : null;
+  } catch (err) {
+    console.warn("[omatrust] EIP-712 signer extraction failed:", err);
+    return null;
+  }
+}
+function extractJwsHeaderJwk(proof) {
+  const jws = proof.proofObject;
+  if (typeof jws !== "string") return null;
+  const parts = jws.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const headerB64 = parts[0].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = headerB64.padEnd(
+      headerB64.length + (4 - headerB64.length % 4) % 4,
+      "="
+    );
+    let headerJson;
+    if (typeof atob === "function") {
+      headerJson = decodeURIComponent(
+        Array.from(atob(padded)).map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`).join("")
+      );
+    } else {
+      headerJson = Buffer.from(padded, "base64").toString("utf8");
+    }
+    const header = JSON.parse(headerJson);
+    return header.jwk ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractJwsPayload(proof) {
+  const jws = proof.proofObject;
+  if (typeof jws !== "string") return null;
+  const parts = jws.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const payloadB64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = payloadB64.padEnd(
+      payloadB64.length + (4 - payloadB64.length % 4) % 4,
+      "="
+    );
+    let payloadJson;
+    if (typeof atob === "function") {
+      payloadJson = decodeURIComponent(
+        Array.from(atob(padded)).map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`).join("")
+      );
+    } else {
+      payloadJson = Buffer.from(padded, "base64").toString("utf8");
+    }
+    return JSON.parse(payloadJson);
+  } catch {
+    return null;
+  }
+}
+function signerMatchesDid(signerAddress, did) {
+  try {
+    const didAddress = extractAddressFromDid(did);
+    return ethers.getAddress(signerAddress).toLowerCase() === ethers.getAddress(didAddress).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function jwkMatchesDid(jwk, did) {
+  const method = extractDidMethod(did);
+  if (method === "jwk") {
+    try {
+      const didJwk = didJwkToJwk(did);
+      return publicJwkEquals(jwk, didJwk);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function proofSignerMatchesDid(proof, did) {
+  switch (proof.proofType) {
+    case "pop-eip712": {
+      const signer = extractEip712Signer(proof);
+      if (!signer) return false;
+      return signerMatchesDid(signer, did);
+    }
+    case "pop-jws": {
+      const jwsProof = proof;
+      const jwk = extractJwsHeaderJwk(jwsProof);
+      if (jwk && jwkMatchesDid(jwk, did)) return true;
+      const payload = extractJwsPayload(jwsProof);
+      if (payload && typeof payload.iss === "string") {
+        if (payload.iss === did) return true;
+      }
+      return false;
+    }
+    case "tx-encoded-value":
+    case "tx-interaction":
+      return false;
+    case "evidence-pointer":
+      return false;
+    default:
+      return false;
+  }
+}
+function proofAuthorizedEntityMatchesDid(proof, did) {
+  switch (proof.proofType) {
+    case "pop-eip712": {
+      const eip712 = proof;
+      const authorizedEntity = eip712.proofObject.message.authorizedEntity;
+      return typeof authorizedEntity === "string" && authorizedEntity === did;
+    }
+    case "pop-jws": {
+      const payload = extractJwsPayload(proof);
+      if (!payload) return false;
+      return typeof payload.aud === "string" && payload.aud === did;
+    }
+    default:
+      return false;
+  }
+}
+function verifyLinkedIdentifierProofs(data) {
+  if (!data.subject || !data.linkedId) {
+    return {
+      valid: false,
+      checks: [],
+      reasons: ["subject and linkedId are required"]
+    };
+  }
+  if (!Array.isArray(data.proofs) || data.proofs.length === 0) {
+    return {
+      valid: false,
+      checks: [],
+      reasons: ["At least one proof is required"]
+    };
+  }
+  const checks = [];
+  let subjectProved = false;
+  let linkedIdProved = false;
+  for (let i = 0; i < data.proofs.length; i++) {
+    const proof = data.proofs[i];
+    if (proofSignerMatchesDid(proof, data.subject)) {
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-subject",
+        valid: true
+      });
+      subjectProved = true;
+      if (!proofAuthorizedEntityMatchesDid(proof, data.linkedId)) {
+        checks.push({
+          proofIndex: i,
+          proofType: proof.proofType,
+          checkType: "signer-is-subject",
+          valid: false,
+          reason: "Proof from subject does not authorize linkedId (aud mismatch)"
+        });
+      }
+    }
+    if (proofSignerMatchesDid(proof, data.linkedId)) {
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-linkedId",
+        valid: true
+      });
+      linkedIdProved = true;
+      if (!proofAuthorizedEntityMatchesDid(proof, data.subject)) {
+        checks.push({
+          proofIndex: i,
+          proofType: proof.proofType,
+          checkType: "signer-is-linkedId",
+          valid: false,
+          reason: "Proof from linkedId does not authorize subject (aud mismatch)"
+        });
+      }
+    }
+    if (proof.proofType === "evidence-pointer") {
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-subject",
+        valid: true,
+        reason: "Evidence pointer accepted (requires URL fetch for full verification)"
+      });
+      subjectProved = true;
+    }
+  }
+  const reasons = [];
+  if (!subjectProved) {
+    reasons.push("No proof demonstrates control by subject");
+  }
+  if (!linkedIdProved) {
+    reasons.push("No proof demonstrates control by linkedId");
+  }
+  return {
+    valid: reasons.length === 0,
+    checks,
+    reasons
+  };
+}
+function verifyKeyBindingProofs(data) {
+  if (!data.subject || !data.keyId) {
+    return {
+      valid: false,
+      checks: [],
+      reasons: ["subject and keyId are required"]
+    };
+  }
+  if (!Array.isArray(data.proofs) || data.proofs.length === 0) {
+    return {
+      valid: false,
+      checks: [],
+      reasons: ["At least one proof is required"]
+    };
+  }
+  const checks = [];
+  let subjectAuthorizedKey = false;
+  for (let i = 0; i < data.proofs.length; i++) {
+    const proof = data.proofs[i];
+    if (proofSignerMatchesDid(proof, data.subject)) {
+      const authorizesKey = proofAuthorizedEntityMatchesDid(proof, data.keyId);
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-subject-for-key",
+        valid: authorizesKey,
+        reason: authorizesKey ? void 0 : "Proof signed by subject but does not authorize the keyId"
+      });
+      if (authorizesKey) {
+        subjectAuthorizedKey = true;
+      }
+    }
+    if (proofSignerMatchesDid(proof, data.keyId)) {
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-keyId",
+        valid: true,
+        reason: "Key proved possession (supplementary, not sufficient alone)"
+      });
+    }
+    if (proof.proofType === "evidence-pointer") {
+      checks.push({
+        proofIndex: i,
+        proofType: proof.proofType,
+        checkType: "signer-is-subject-for-key",
+        valid: true,
+        reason: "Evidence pointer accepted (requires URL fetch for full verification)"
+      });
+      subjectAuthorizedKey = true;
+    }
+  }
+  if (data.publicKeyJwk && extractDidMethod(data.keyId) === "jwk") {
+    try {
+      const keyIdJwk = didJwkToJwk(data.keyId);
+      const jwkConsistent = publicJwkEquals(data.publicKeyJwk, keyIdJwk);
+      if (!jwkConsistent) {
+        return {
+          valid: false,
+          checks,
+          reasons: ["publicKeyJwk does not match the key material in keyId (did:jwk)"]
+        };
+      }
+    } catch {
+    }
+  }
+  const reasons = [];
+  if (!subjectAuthorizedKey) {
+    reasons.push(
+      "No proof demonstrates that subject authorized the key binding"
+    );
+  }
+  return {
+    valid: reasons.length === 0,
+    checks,
+    reasons
+  };
+}
 
 exports.EIP1967_ADMIN_SLOT = EIP1967_ADMIN_SLOT;
 exports.OWNERSHIP_PATTERNS = OWNERSHIP_PATTERNS;
@@ -3216,10 +3550,13 @@ exports.verifyDidPkhOwnership = verifyDidPkhOwnership;
 exports.verifyDidWebOwnership = verifyDidWebOwnership;
 exports.verifyDnsTxtControllerDid = verifyDnsTxtControllerDid2;
 exports.verifyEip712Signature = verifyEip712Signature;
+exports.verifyKeyBindingProofs = verifyKeyBindingProofs;
+exports.verifyLinkedIdentifierProofs = verifyLinkedIdentifierProofs;
 exports.verifyProof = verifyProof;
 exports.verifySchemaExists = verifySchemaExists;
 exports.verifySubjectOwnership = verifySubjectOwnership;
 exports.verifyTransferProof = verifyTransferProof;
+exports.verifyX402Artifact = verifyX402Artifact;
 exports.verifyX402Eip712Artifact = verifyX402Eip712Artifact;
 exports.verifyX402Eip712Offer = verifyX402Eip712Offer;
 exports.verifyX402Eip712Receipt = verifyX402Eip712Receipt;