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

package/dist/reputation/index.browser.js

@@ -0,0 +1,2946 @@
+import { ZeroAddress, Signature, toUtf8Bytes, sha256, keccak256, formatUnits, getAddress, isAddress, verifyTypedData, hexlify, randomBytes, Contract, Interface } from 'ethers';
+import { base64url, decodeProtectedHeader, importJWK, compactVerify } from 'jose';
+import { SchemaEncoder, EAS } from '@ethereum-attestation-service/eas-sdk';
+import canonicalize from 'canonicalize';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/errors.ts
+var OmaTrustError;
+var init_errors = __esm({
+  "src/shared/errors.ts"() {
+    OmaTrustError = class extends Error {
+      code;
+      details;
+      constructor(code, message, details) {
+        super(message);
+        this.name = "OmaTrustError";
+        this.code = code;
+        this.details = details;
+      }
+    };
+  }
+});
+
+// src/shared/assert.ts
+function assertString(value, name, code = "INVALID_INPUT") {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new OmaTrustError(code, `${name} must be a non-empty string`, { value });
+  }
+}
+function assertObject(value, name, code = "INVALID_INPUT") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new OmaTrustError(code, `${name} must be an object`, { value });
+  }
+}
+var init_assert = __esm({
+  "src/shared/assert.ts"() {
+    init_errors();
+  }
+});
+
+// src/identity/caip.ts
+function parseCaip10(input) {
+  assertString(input, "input", "INVALID_CAIP");
+  const trimmed = input.trim();
+  const match = trimmed.match(CAIP_10_REGEX);
+  if (!match?.groups) {
+    throw new OmaTrustError("INVALID_CAIP", "Invalid CAIP-10 format", { input });
+  }
+  const namespace = match.groups.namespace;
+  const reference = match.groups.reference;
+  const address = match.groups.address;
+  if (!namespace || !reference || !address) {
+    throw new OmaTrustError("INVALID_CAIP", "Invalid CAIP-10 components", { input });
+  }
+  return { namespace, reference, address };
+}
+var CAIP_10_REGEX;
+var init_caip = __esm({
+  "src/identity/caip.ts"() {
+    init_errors();
+    init_assert();
+    CAIP_10_REGEX = /^(?<namespace>[a-z0-9-]+):(?<reference>[a-zA-Z0-9-]+):(?<address>.+)$/;
+  }
+});
+function isValidDid(did) {
+  return DID_REGEX.test(did);
+}
+function extractDidMethod(did) {
+  const match = did.match(/^did:([a-z0-9]+):/i);
+  return match ? match[1] : null;
+}
+function normalizeDomain(domain) {
+  assertString(domain, "domain", "INVALID_DID");
+  return domain.trim().toLowerCase().replace(/\.$/, "").replace(/^www\./, "");
+}
+function normalizeDidWeb(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (trimmed.startsWith("did:") && !trimmed.startsWith("did:web:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected did:web DID", { input });
+  }
+  const identifier = trimmed.startsWith("did:web:") ? trimmed.slice("did:web:".length) : trimmed;
+  const [host, ...pathParts] = identifier.split("/");
+  if (!host) {
+    throw new OmaTrustError("INVALID_DID", "Invalid did:web identifier", { input });
+  }
+  const normalizedHost = normalizeDomain(host);
+  const path = pathParts.length > 0 ? `/${pathParts.join("/")}` : "";
+  return `did:web:${normalizedHost}${path}`;
+}
+function normalizeDidPkh(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("did:pkh:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected did:pkh DID", { input });
+  }
+  const parts = trimmed.split(":");
+  if (parts.length !== 5) {
+    throw new OmaTrustError("INVALID_DID", "Invalid did:pkh format", { input });
+  }
+  const [, , namespace, chainId, address] = parts;
+  if (!namespace || !chainId || !address) {
+    throw new OmaTrustError("INVALID_DID", "Invalid did:pkh components", { input });
+  }
+  return `did:pkh:${namespace.toLowerCase()}:${chainId}:${address.toLowerCase()}`;
+}
+function normalizeDidHandle(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("did:handle:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected did:handle DID", { input });
+  }
+  const parts = trimmed.split(":");
+  if (parts.length !== 4) {
+    throw new OmaTrustError("INVALID_DID", "Invalid did:handle format", { input });
+  }
+  const [, , platform, username] = parts;
+  if (!platform || !username) {
+    throw new OmaTrustError("INVALID_DID", "Invalid did:handle components", { input });
+  }
+  return `did:handle:${platform.toLowerCase()}:${username}`;
+}
+function normalizeDidKey(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("did:key:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected did:key DID", { input });
+  }
+  return trimmed;
+}
+function normalizeDid(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("did:")) {
+    return normalizeDidWeb(trimmed);
+  }
+  if (!isValidDid(trimmed)) {
+    throw new OmaTrustError("INVALID_DID", "Invalid DID format", { input });
+  }
+  const method = extractDidMethod(trimmed);
+  switch (method) {
+    case "web":
+      return normalizeDidWeb(trimmed);
+    case "pkh":
+      return normalizeDidPkh(trimmed);
+    case "handle":
+      return normalizeDidHandle(trimmed);
+    case "key":
+      return normalizeDidKey(trimmed);
+    case "jwk":
+      return normalizeDidJwk(trimmed);
+    default:
+      return trimmed;
+  }
+}
+function computeDidHash(did) {
+  const normalized = normalizeDid(did);
+  return keccak256(toUtf8Bytes(normalized));
+}
+function computeDidAddress(didHash) {
+  assertString(didHash, "didHash", "INVALID_DID");
+  if (!/^0x[0-9a-fA-F]{64}$/.test(didHash)) {
+    throw new OmaTrustError("INVALID_DID", "didHash must be 32-byte hex", { didHash });
+  }
+  return `0x${didHash.slice(-40).toLowerCase()}`;
+}
+function didToAddress(did) {
+  return computeDidAddress(computeDidHash(did));
+}
+function buildDidPkh(namespace, chainId, address) {
+  assertString(namespace, "namespace", "INVALID_DID");
+  assertString(address, "address", "INVALID_DID");
+  if (chainId === "" || chainId === null || chainId === void 0) {
+    throw new OmaTrustError("INVALID_DID", "chainId is required", { chainId });
+  }
+  return `did:pkh:${namespace.toLowerCase()}:${chainId}:${address.toLowerCase()}`;
+}
+function buildEvmDidPkh(chainId, address) {
+  return buildDidPkh("eip155", chainId, address);
+}
+function parseDidPkh(did) {
+  if (!did.startsWith("did:pkh:")) {
+    return null;
+  }
+  const parts = did.split(":");
+  if (parts.length !== 5) {
+    return null;
+  }
+  const [, , namespace, chainId, address] = parts;
+  if (!namespace || !chainId || !address) {
+    return null;
+  }
+  return { namespace, chainId, address };
+}
+function getChainIdFromDidPkh(did) {
+  return parseDidPkh(did)?.chainId ?? null;
+}
+function getAddressFromDidPkh(did) {
+  return parseDidPkh(did)?.address ?? null;
+}
+function getNamespaceFromDidPkh(did) {
+  return parseDidPkh(did)?.namespace ?? null;
+}
+function isEvmDidPkh(did) {
+  return getNamespaceFromDidPkh(did) === "eip155";
+}
+function getDomainFromDidWeb(did) {
+  if (!did.startsWith("did:web:")) {
+    return null;
+  }
+  const identifier = did.slice("did:web:".length);
+  const [domain] = identifier.split("/");
+  return domain || null;
+}
+function extractAddressFromDid(identifier) {
+  assertString(identifier, "identifier", "INVALID_DID");
+  if (identifier.startsWith("did:pkh:")) {
+    const pkh = parseDidPkh(normalizeDidPkh(identifier));
+    if (!pkh) {
+      throw new OmaTrustError("INVALID_DID", "Invalid did:pkh identifier", { identifier });
+    }
+    return pkh.address;
+  }
+  if (identifier.startsWith("did:ethr:")) {
+    const parts = identifier.replace("did:ethr:", "").split(":");
+    const address = parts.length === 1 ? parts[0] : parts[1];
+    if (!address || !isAddress(address)) {
+      throw new OmaTrustError("INVALID_DID", "Invalid did:ethr identifier", { identifier });
+    }
+    return getAddress(address);
+  }
+  if (identifier.match(/^[a-z0-9-]+:[a-zA-Z0-9-]+:0x[a-fA-F0-9]{40}$/)) {
+    const parsed = parseCaip10(identifier);
+    return parsed.address;
+  }
+  if (isAddress(identifier)) {
+    return getAddress(identifier);
+  }
+  throw new OmaTrustError("INVALID_DID", "Unsupported identifier format", { identifier });
+}
+function validateDidJwk(did) {
+  const parts = did.split(":");
+  if (parts.length !== 3) {
+    return {
+      valid: false,
+      method: "jwk",
+      error: `did:jwk must have exactly 3 colon-separated parts, got ${parts.length}`
+    };
+  }
+  const [, , encoded] = parts;
+  if (!encoded || encoded.length === 0) {
+    return { valid: false, method: "jwk", error: "Missing base64url-encoded JWK identifier" };
+  }
+  if (!BASE64URL_REGEX.test(encoded)) {
+    return {
+      valid: false,
+      method: "jwk",
+      error: "Identifier contains invalid base64url characters"
+    };
+  }
+  let decoded;
+  try {
+    const bytes = base64url.decode(encoded);
+    decoded = new TextDecoder().decode(bytes);
+  } catch {
+    return { valid: false, method: "jwk", error: "Failed to base64url-decode identifier" };
+  }
+  let jwk;
+  try {
+    jwk = JSON.parse(decoded);
+  } catch {
+    return { valid: false, method: "jwk", error: "Decoded identifier is not valid JSON" };
+  }
+  if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) {
+    return { valid: false, method: "jwk", error: "Decoded JWK must be a JSON object" };
+  }
+  const kty = jwk.kty;
+  if (typeof kty !== "string" || !VALID_JWK_KTY.has(kty)) {
+    return {
+      valid: false,
+      method: "jwk",
+      error: `Invalid or missing kty field (must be one of: EC, OKP, RSA)`
+    };
+  }
+  if ("d" in jwk) {
+    return {
+      valid: false,
+      method: "jwk",
+      error: "DID must reference a public key \u2014 private key component (d) is not allowed"
+    };
+  }
+  return { valid: true, method: "jwk" };
+}
+function normalizeDidJwk(input) {
+  assertString(input, "input", "INVALID_DID");
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("did:jwk:")) {
+    throw new OmaTrustError("INVALID_DID", "Expected did:jwk DID", { input });
+  }
+  const result = validateDidJwk(trimmed);
+  if (!result.valid) {
+    throw new OmaTrustError("INVALID_DID", result.error ?? "Invalid did:jwk", { input });
+  }
+  return trimmed;
+}
+var DID_REGEX, BASE64URL_REGEX, VALID_JWK_KTY;
+var init_did = __esm({
+  "src/identity/did.ts"() {
+    init_errors();
+    init_assert();
+    init_caip();
+    DID_REGEX = /^did:[a-z0-9]+:.+$/i;
+    BASE64URL_REGEX = /^[A-Za-z0-9_-]+$/;
+    VALID_JWK_KTY = /* @__PURE__ */ new Set(["EC", "OKP", "RSA"]);
+  }
+});
+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 = 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 = 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);
+}
+var VALID_KTY, PRIVATE_KEY_FIELDS, REQUIRED_PUBLIC_FIELDS;
+var init_jwk = __esm({
+  "src/identity/jwk.ts"() {
+    init_errors();
+    init_assert();
+    VALID_KTY = /* @__PURE__ */ new Set(["EC", "OKP", "RSA"]);
+    PRIVATE_KEY_FIELDS = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth"]);
+    REQUIRED_PUBLIC_FIELDS = {
+      EC: ["crv", "x", "y"],
+      OKP: ["crv", "x"],
+      RSA: ["n", "e"]
+    };
+  }
+});
+
+// src/reputation/proof/dns-txt-record.ts
+function parseDnsTxtRecord(record) {
+  if (!record || typeof record !== "string") {
+    throw new OmaTrustError("INVALID_INPUT", "record must be a non-empty string", { record });
+  }
+  const entries = record.split(/[;\s]+/).map((entry) => entry.trim()).filter(Boolean);
+  const parsed = {};
+  const controllers = [];
+  for (const entry of entries) {
+    const eqIndex = entry.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = entry.slice(0, eqIndex).trim();
+    const value = entry.slice(eqIndex + 1).trim();
+    if (!key || !value) continue;
+    if (key === "controller") {
+      controllers.push(value);
+    } else {
+      parsed[key] = value;
+    }
+  }
+  return {
+    version: parsed.v,
+    controller: controllers[0],
+    controllers
+  };
+}
+function buildDnsTxtRecord(controllerDid) {
+  const normalized = normalizeDid(controllerDid);
+  return `v=1;controller=${normalized}`;
+}
+var init_dns_txt_record = __esm({
+  "src/reputation/proof/dns-txt-record.ts"() {
+    init_did();
+    init_errors();
+  }
+});
+
+// src/identity/controller-id.ts
+function isSameControllerId(a, b) {
+  let normalizedA = null;
+  let normalizedB = null;
+  try {
+    normalizedA = normalizeDid(a);
+  } catch {
+  }
+  try {
+    normalizedB = normalizeDid(b);
+  } catch {
+  }
+  if (normalizedA && normalizedB && normalizedA === normalizedB) {
+    return true;
+  }
+  const evmA = extractControllerEvmAddress(a);
+  const evmB = extractControllerEvmAddress(b);
+  if (evmA && evmB && evmA.toLowerCase() === evmB.toLowerCase()) {
+    return true;
+  }
+  const methodA = extractDidMethod(a);
+  const methodB = extractDidMethod(b);
+  if (methodA === "jwk" && methodB === "jwk") {
+    try {
+      const jwkA = didJwkToJwk(a);
+      const jwkB = didJwkToJwk(b);
+      return publicJwkEquals(jwkA, jwkB);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function extractControllerEvmAddress(controllerDid) {
+  try {
+    const method = extractDidMethod(controllerDid);
+    if (method === "pkh" && controllerDid.includes("eip155")) {
+      return extractAddressFromDid(controllerDid);
+    }
+  } catch {
+  }
+  return null;
+}
+var init_controller_id = __esm({
+  "src/identity/controller-id.ts"() {
+    init_did();
+    init_jwk();
+  }
+});
+
+// src/reputation/proof/dns-txt-shared.ts
+var dns_txt_shared_exports = {};
+__export(dns_txt_shared_exports, {
+  verifyDnsTxtControllerDid: () => verifyDnsTxtControllerDid
+});
+async function verifyDnsTxtControllerDid(domain, expectedControllerDid, options = {}) {
+  if (!domain || typeof domain !== "string") {
+    throw new OmaTrustError("INVALID_INPUT", "domain must be a non-empty string", { domain });
+  }
+  if (!options.resolveTxt) {
+    throw new OmaTrustError("NETWORK_ERROR", "No DNS TXT resolver was provided", { domain });
+  }
+  const prefix = options.recordPrefix ?? "_controllers";
+  const host = `${prefix}.${domain.toLowerCase().replace(/\.$/, "")}`;
+  let records;
+  try {
+    records = await options.resolveTxt(host);
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to resolve DNS TXT records", { domain, err });
+  }
+  for (const recordParts of records) {
+    const record = recordParts.join("");
+    const parsed = parseDnsTxtRecord(record);
+    if (parsed.version !== "1") continue;
+    for (const recordController of parsed.controllers) {
+      if (isSameControllerId(recordController, expectedControllerDid)) {
+        return { valid: true, record };
+      }
+    }
+  }
+  return { valid: false, reason: "Controller DID not found in DNS TXT records" };
+}
+var init_dns_txt_shared = __esm({
+  "src/reputation/proof/dns-txt-shared.ts"() {
+    init_controller_id();
+    init_errors();
+    init_dns_txt_record();
+  }
+});
+
+// src/reputation/encode.ts
+init_errors();
+function normalizeSchema(schema) {
+  if (Array.isArray(schema)) {
+    if (schema.length === 0) {
+      throw new OmaTrustError("INVALID_INPUT", "schema array cannot be empty");
+    }
+    return schema;
+  }
+  if (typeof schema !== "string" || schema.trim().length === 0) {
+    throw new OmaTrustError("INVALID_INPUT", "schema must be a non-empty string or SchemaField[]");
+  }
+  const fields = schema.split(",").map((part) => part.trim()).filter((part) => part.length > 0).map((part) => {
+    const pieces = part.split(/\s+/);
+    if (pieces.length < 2) {
+      throw new OmaTrustError("INVALID_INPUT", "Invalid schema field", { part });
+    }
+    const type = pieces[0];
+    const name = pieces.slice(1).join(" ");
+    return { type, name };
+  });
+  if (fields.length === 0) {
+    throw new OmaTrustError("INVALID_INPUT", "No schema fields found");
+  }
+  return fields;
+}
+function schemaToString(schema) {
+  if (typeof schema === "string") {
+    return schema;
+  }
+  return schema.map((field) => `${field.type} ${field.name}`).join(", ");
+}
+function encodeAttestationData(schema, data) {
+  if (!data || typeof data !== "object") {
+    throw new OmaTrustError("INVALID_INPUT", "data must be an object");
+  }
+  const validationErrors = validateAttestationData(schema, data);
+  if (validationErrors.length > 0) {
+    const summary = validationErrors.map((error) => `Field "${error.schemaFieldName}" (${error.expectedType}) got ${error.providedType}`).join("; ");
+    throw new OmaTrustError("INVALID_INPUT", `Attestation data validation failed: ${summary}`, {
+      errors: validationErrors
+    });
+  }
+  const fields = normalizeSchema(schema);
+  const schemaString = schemaToString(fields);
+  const encoder = new SchemaEncoder(schemaString);
+  const encoded = encoder.encodeData(
+    fields.map((field) => ({
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    }))
+  );
+  return encoded;
+}
+function getActualType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? "number" : "non-finite-number";
+  }
+  return typeof value;
+}
+function isNumericValue(value, allowNegative) {
+  if (typeof value === "bigint") {
+    return allowNegative || value >= 0n;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      return false;
+    }
+    return allowNegative || value >= 0;
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      return false;
+    }
+    const pattern = allowNegative ? /^-?\d+$/ : /^\d+$/;
+    return pattern.test(value);
+  }
+  return false;
+}
+function isHex(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]*$/.test(value);
+}
+function validateFieldValue(type, value) {
+  const normalizedType = type.trim().toLowerCase();
+  const bytesNMatch = normalizedType.match(/^bytes([1-9]|[12]\d|3[0-2])$/);
+  if (/^uint\d*$/.test(normalizedType)) {
+    return isNumericValue(value, false);
+  }
+  if (/^int\d*$/.test(normalizedType)) {
+    return isNumericValue(value, true);
+  }
+  if (normalizedType === "string") {
+    return typeof value === "string";
+  }
+  if (normalizedType === "string[]") {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+  }
+  if (normalizedType === "bool") {
+    return typeof value === "boolean";
+  }
+  if (normalizedType === "address") {
+    return typeof value === "string" && isAddress(value);
+  }
+  if (normalizedType === "bytes") {
+    return isHex(value) && (value.length - 2) % 2 === 0;
+  }
+  if (bytesNMatch) {
+    const expectedBytes = Number(bytesNMatch[1]);
+    return isHex(value) && value.length === 2 + expectedBytes * 2;
+  }
+  return true;
+}
+function validateAttestationData(schema, data) {
+  if (!data || typeof data !== "object") {
+    return [{
+      schemaFieldName: "data",
+      expectedType: "object",
+      providedType: getActualType(data),
+      providedValue: data
+    }];
+  }
+  const fields = normalizeSchema(schema);
+  const errors = [];
+  for (const field of fields) {
+    const value = data[field.name];
+    const isValid = validateFieldValue(field.type, value);
+    if (isValid) {
+      continue;
+    }
+    errors.push({
+      schemaFieldName: field.name,
+      expectedType: field.type,
+      providedType: getActualType(value),
+      providedValue: value
+    });
+  }
+  return errors;
+}
+function decodeAttestationData(schema, encodedData) {
+  if (typeof encodedData !== "string" || !encodedData.startsWith("0x")) {
+    throw new OmaTrustError("INVALID_INPUT", "encodedData must be a hex string");
+  }
+  const fields = normalizeSchema(schema);
+  const schemaString = schemaToString(fields);
+  const encoder = new SchemaEncoder(schemaString);
+  const decoded = encoder.decodeData(encodedData);
+  const result = {};
+  for (const item of decoded) {
+    const value = item.value;
+    if (value && typeof value === "object" && "value" in value) {
+      result[item.name] = value.value;
+    } else {
+      result[item.name] = value;
+    }
+  }
+  return result;
+}
+function extractExpirationTime(data) {
+  const value = data["expiresAt"];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
+  return void 0;
+}
+
+// src/reputation/internal.ts
+init_did();
+var ZERO_UID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function toBigIntOrDefault(value, fallback) {
+  if (value === void 0 || value === null) {
+    return fallback;
+  }
+  return typeof value === "bigint" ? value : BigInt(Math.floor(value));
+}
+function withAutoSubjectDidHash(schema, data) {
+  const fields = normalizeSchema(schema);
+  const hasSubjectDidHash = fields.some((field) => field.name === "subjectDidHash");
+  if (!hasSubjectDidHash) {
+    return { ...data };
+  }
+  const subject = data.subject;
+  if (typeof subject === "string" && subject.startsWith("did:")) {
+    return {
+      ...data,
+      subjectDidHash: computeDidHash(subject)
+    };
+  }
+  return { ...data };
+}
+function resolveRecipientAddress(data) {
+  const subject = data.subject;
+  if (typeof subject === "string" && subject.startsWith("did:")) {
+    return didToAddress(subject);
+  }
+  const subjectDidHash = data.subjectDidHash;
+  if (typeof subjectDidHash === "string" && /^0x[0-9a-fA-F]{64}$/.test(subjectDidHash)) {
+    return computeDidAddress(subjectDidHash);
+  }
+  const recipient = data.recipient;
+  if (typeof recipient === "string" && isAddress(recipient)) {
+    return getAddress(recipient);
+  }
+  return ZeroAddress;
+}
+
+// src/reputation/eas-adapter.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function isHex32(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+function getEasTransactionReceipt(tx) {
+  if (!isRecord(tx)) {
+    return void 0;
+  }
+  const candidates = [tx.receipt, tx.tx, tx.transaction];
+  for (const candidate of candidates) {
+    if (isRecord(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function getEasTransactionHash(tx) {
+  const receipt = getEasTransactionReceipt(tx);
+  if (receipt) {
+    const receiptHash = receipt.hash;
+    if (isHex32(receiptHash)) {
+      return receiptHash;
+    }
+    const transactionHash = receipt.transactionHash;
+    if (isHex32(transactionHash)) {
+      return transactionHash;
+    }
+  }
+  if (isRecord(tx) && isHex32(tx.hash)) {
+    return tx.hash;
+  }
+  return void 0;
+}
+function isEasSchemaNotFoundError(err) {
+  if (!isRecord(err)) {
+    return false;
+  }
+  const message = err.message;
+  if (typeof message !== "string" || message.length === 0) {
+    return false;
+  }
+  return /schema not found/i.test(message);
+}
+
+// src/reputation/submit.ts
+init_errors();
+async function submitAttestation(params) {
+  if (!params || typeof params !== "object") {
+    throw new OmaTrustError("INVALID_INPUT", "params must be provided");
+  }
+  if (!params.signer) {
+    throw new OmaTrustError("INVALID_INPUT", "signer is required");
+  }
+  const dataWithHash = withAutoSubjectDidHash(params.schema, params.data);
+  const encodedData = encodeAttestationData(params.schema, dataWithHash);
+  const expiration = toBigIntOrDefault(
+    params.expirationTime ?? extractExpirationTime(dataWithHash),
+    0n
+  );
+  const recipient = resolveRecipientAddress(dataWithHash);
+  const eas = new EAS(params.easContractAddress);
+  eas.connect(params.signer);
+  try {
+    const tx = await eas.attest({
+      schema: params.schemaUid,
+      data: {
+        recipient: recipient || ZeroAddress,
+        expirationTime: expiration,
+        revocable: params.revocable ?? true,
+        refUID: params.refUid ?? ZERO_UID,
+        data: encodedData,
+        value: toBigIntOrDefault(params.value, 0n)
+      }
+    });
+    const uid = await tx.wait();
+    const txHash = getEasTransactionHash(tx) ?? ZERO_UID;
+    const receipt = getEasTransactionReceipt(tx);
+    return {
+      uid,
+      txHash,
+      receipt
+    };
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to submit attestation", { err });
+  }
+}
+init_errors();
+async function revokeAttestation(params) {
+  if (!params || typeof params !== "object") {
+    throw new OmaTrustError("INVALID_INPUT", "params must be provided");
+  }
+  if (!params.signer) {
+    throw new OmaTrustError("INVALID_INPUT", "signer is required");
+  }
+  const eas = new EAS(params.easContractAddress);
+  eas.connect(params.signer);
+  try {
+    const tx = await eas.revoke({
+      schema: params.schemaUid,
+      data: {
+        uid: params.uid,
+        value: toBigIntOrDefault(params.value, 0n)
+      }
+    });
+    await tx.wait();
+    const txHash = getEasTransactionHash(tx) ?? ZERO_UID;
+    const receipt = getEasTransactionReceipt(tx);
+    return {
+      txHash,
+      receipt
+    };
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to revoke attestation", { err });
+  }
+}
+init_errors();
+function buildDelegatedTypedData(params) {
+  return {
+    domain: {
+      name: "EAS",
+      version: "1.4.0",
+      chainId: params.chainId,
+      verifyingContract: params.easContractAddress
+    },
+    types: {
+      Attest: [
+        { name: "attester", type: "address" },
+        { name: "schema", type: "bytes32" },
+        { name: "recipient", type: "address" },
+        { name: "expirationTime", type: "uint64" },
+        { name: "revocable", type: "bool" },
+        { name: "refUID", type: "bytes32" },
+        { name: "data", type: "bytes" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint64" }
+      ]
+    },
+    message: {
+      attester: params.attester,
+      schema: params.schemaUid,
+      recipient: params.recipient,
+      expirationTime: toBigIntOrDefault(params.expirationTime, 0n),
+      revocable: params.revocable ?? true,
+      refUID: params.refUid ?? ZERO_UID,
+      data: params.encodedData,
+      value: toBigIntOrDefault(params.value, 0n),
+      nonce: toBigIntOrDefault(params.nonce, 0n),
+      deadline: toBigIntOrDefault(params.deadline, BigInt(Math.floor(Date.now() / 1e3) + 600))
+    }
+  };
+}
+function buildDelegatedAttestationTypedData(params) {
+  const dataWithHash = withAutoSubjectDidHash(params.schema, params.data);
+  const encodedData = encodeAttestationData(params.schema, dataWithHash);
+  const recipient = resolveRecipientAddress(dataWithHash);
+  return buildDelegatedTypedData({
+    chainId: params.chainId,
+    easContractAddress: params.easContractAddress,
+    schemaUid: params.schemaUid,
+    encodedData,
+    recipient,
+    attester: params.attester,
+    nonce: params.nonce,
+    revocable: params.revocable,
+    expirationTime: params.expirationTime ?? extractExpirationTime(dataWithHash),
+    refUid: params.refUid,
+    value: params.value,
+    deadline: params.deadline
+  });
+}
+function buildDelegatedTypedDataFromEncoded(params) {
+  return buildDelegatedTypedData({
+    chainId: params.chainId,
+    easContractAddress: params.easContractAddress,
+    schemaUid: params.schemaUid,
+    encodedData: params.encodedData,
+    recipient: params.recipient,
+    attester: params.attester,
+    nonce: params.nonce,
+    revocable: params.revocable,
+    expirationTime: params.expirationTime,
+    refUid: params.refUid,
+    value: params.value,
+    deadline: params.deadline
+  });
+}
+function splitSignature(signature) {
+  try {
+    const parsed = Signature.from(signature);
+    return {
+      v: parsed.v,
+      r: parsed.r,
+      s: parsed.s
+    };
+  } catch (err) {
+    throw new OmaTrustError("INVALID_INPUT", "Invalid signature", { err });
+  }
+}
+async function prepareDelegatedAttestation(params) {
+  if (!params || typeof params !== "object") {
+    throw new OmaTrustError("INVALID_INPUT", "params are required");
+  }
+  const typedData = buildDelegatedAttestationTypedData(params);
+  return {
+    delegatedRequest: {
+      schema: params.schemaUid,
+      attester: params.attester,
+      easContractAddress: params.easContractAddress,
+      chainId: params.chainId,
+      ...typedData.message
+    },
+    typedData
+  };
+}
+async function submitDelegatedAttestation(params) {
+  if (!params.relayUrl || typeof params.relayUrl !== "string") {
+    throw new OmaTrustError("INVALID_INPUT", "relayUrl is required");
+  }
+  let response;
+  try {
+    const body = JSON.stringify(
+      {
+        prepared: params.prepared,
+        signature: params.signature,
+        attester: params.attester
+      },
+      (_key, value) => typeof value === "bigint" ? value.toString() : value
+    );
+    response = await fetch(params.relayUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body
+    });
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to submit delegated attestation", { err });
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    payload = {};
+  }
+  if (!response.ok) {
+    const relayError = {
+      httpStatus: response.status,
+      code: payload.code,
+      error: payload.error ?? payload.message,
+      payload
+    };
+    throw new OmaTrustError("RELAY_ERROR", `Relay submission failed (HTTP ${response.status})`, relayError);
+  }
+  const uid = payload.uid ?? ZERO_UID;
+  const txHash = payload.txHash;
+  const hasConfirmationSignals = payload.status === "confirmed" || payload.success === true || typeof payload.blockNumber === "number";
+  const status = hasConfirmationSignals ? "confirmed" : "submitted";
+  const relay = {};
+  if (typeof payload.blockNumber === "number") relay.blockNumber = payload.blockNumber;
+  if (typeof payload.chain === "string") relay.chain = payload.chain;
+  if (typeof payload.success === "boolean") relay.success = payload.success;
+  for (const key of Object.keys(payload)) {
+    if (!["uid", "txHash", "status", "blockNumber", "chain", "success"].includes(key)) {
+      relay[key] = payload[key];
+    }
+  }
+  const result = { uid, txHash, status };
+  if (Object.keys(relay).length > 0) {
+    result.relay = relay;
+  }
+  return result;
+}
+
+// src/reputation/query.ts
+init_did();
+init_errors();
+var EAS_EVENT_ABI = [
+  "event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID)"
+];
+function parseEventTxHash(event) {
+  const txHash = event.transactionHash;
+  if (typeof txHash !== "string") {
+    return void 0;
+  }
+  return /^0x[0-9a-fA-F]{64}$/.test(txHash) ? txHash : void 0;
+}
+function parseAttestation(attestation, schema, txHash) {
+  const rawData = attestation.data ?? "0x";
+  const decoded = schema ? decodeAttestationData(schema, rawData) : {};
+  const toBigIntSafe = (value) => {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return BigInt(value);
+    }
+    if (typeof value === "string" && value.length > 0) {
+      return BigInt(value);
+    }
+    return 0n;
+  };
+  return {
+    uid: attestation.uid,
+    schema: attestation.schema,
+    attester: attestation.attester,
+    recipient: attestation.recipient,
+    txHash,
+    revocable: Boolean(attestation.revocable),
+    revocationTime: toBigIntSafe(attestation.revocationTime),
+    expirationTime: toBigIntSafe(attestation.expirationTime),
+    time: toBigIntSafe(attestation.time),
+    refUID: attestation.refUID,
+    data: decoded,
+    raw: schema ? void 0 : rawData
+  };
+}
+async function getAttestation(params) {
+  try {
+    const eas = new EAS(params.easContractAddress);
+    eas.connect(params.provider);
+    const attestation = await eas.getAttestation(params.uid);
+    if (!attestation || !attestation.uid || String(attestation.uid) === "0x".padEnd(66, "0")) {
+      throw new OmaTrustError("ATTESTATION_NOT_FOUND", "Attestation not found", { uid: params.uid });
+    }
+    return parseAttestation(attestation, params.schema);
+  } catch (err) {
+    if (err instanceof OmaTrustError) {
+      throw err;
+    }
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to read attestation", { err });
+  }
+}
+async function queryAttestationEvents(easContractAddress, provider, fromBlock, toBlock, options) {
+  const contract = new Contract(easContractAddress, EAS_EVENT_ABI, provider);
+  const filter = contract.filters.Attested(options?.recipient ?? null, options?.attester ?? null);
+  let events;
+  try {
+    events = await contract.queryFilter(filter, fromBlock, toBlock);
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to query attestation events", { err });
+  }
+  const eas = new EAS(easContractAddress);
+  eas.connect(provider);
+  const schemaFilter = options?.schemas?.map((s) => s.toLowerCase());
+  const results = [];
+  for (const event of events) {
+    if (!("args" in event && Array.isArray(event.args))) {
+      continue;
+    }
+    const args = event.args;
+    const uid = args?.[2];
+    const schemaUid = args?.[3];
+    if (!uid || !schemaUid) {
+      continue;
+    }
+    if (schemaFilter && !schemaFilter.includes(schemaUid.toLowerCase())) {
+      continue;
+    }
+    const attestation = await eas.getAttestation(uid);
+    if (!attestation || !attestation.uid) {
+      continue;
+    }
+    results.push(parseAttestation(attestation, void 0, parseEventTxHash(event)));
+  }
+  results.sort((a, b) => Number(b.time - a.time));
+  return results;
+}
+async function getAttestationsForDid(params) {
+  const provider = params.provider;
+  const toBlock = params.toBlock ?? await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  return queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { recipient: didToAddress(params.subjectDid), schemas: params.schemas }
+  );
+}
+async function getAttestationsByAttester(params) {
+  const provider = params.provider;
+  const toBlock = params.toBlock ?? await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  if (params.limit !== void 0 && params.limit <= 0) {
+    return [];
+  }
+  const results = await queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { attester: params.attester, schemas: params.schemas }
+  );
+  return params.limit !== void 0 ? results.slice(0, params.limit) : results;
+}
+async function listAttestations(params) {
+  const limit = params.limit ?? 20;
+  if (limit <= 0) {
+    return [];
+  }
+  const results = await getAttestationsForDid(params);
+  return results.slice(0, limit);
+}
+async function getLatestAttestations(params) {
+  const provider = params.provider;
+  const toBlock = await provider.getBlockNumber();
+  const fromBlock = params.fromBlock ?? Math.max(0, toBlock - 5e4);
+  const results = await queryAttestationEvents(
+    params.easContractAddress,
+    provider,
+    fromBlock,
+    toBlock,
+    { schemas: params.schemas }
+  );
+  return results.slice(0, params.limit ?? 20);
+}
+function deduplicateReviews(attestations) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const attestation of attestations) {
+    const subject = String(attestation.data.subject ?? "");
+    const version = String(attestation.data.version ?? "");
+    const major = getMajorVersion(version);
+    const key = `${attestation.attester.toLowerCase()}|${subject}|${major}`;
+    if (!seen.has(key)) {
+      seen.set(key, attestation);
+      continue;
+    }
+    const current = seen.get(key);
+    if (attestation.time > current.time) {
+      seen.set(key, attestation);
+    }
+  }
+  return [...seen.values()];
+}
+function calculateAverageUserReviewRating(attestations) {
+  const deduped = deduplicateReviews(attestations);
+  const ratings = deduped.map((attestation) => attestation.data.ratingValue).filter((value) => typeof value === "number" || typeof value === "bigint").map((value) => Number(value));
+  if (ratings.length === 0) {
+    return 0;
+  }
+  const total = ratings.reduce((sum, value) => sum + value, 0);
+  return total / ratings.length;
+}
+function getMajorVersion(version) {
+  const match = version.match(/^(\d+)/);
+  if (!match) {
+    throw new OmaTrustError("INVALID_INPUT", "Invalid semantic version", { version });
+  }
+  return Number(match[1]);
+}
+
+// src/reputation/verify.ts
+init_did();
+init_errors();
+
+// src/reputation/proof/tx-encoded-value.ts
+init_did();
+init_errors();
+var CHAIN_CONFIGS = {
+  1: {
+    decimals: 18,
+    nativeSymbol: "ETH",
+    explorer: "https://etherscan.io",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  10: {
+    decimals: 18,
+    nativeSymbol: "ETH",
+    explorer: "https://optimistic.etherscan.io",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  137: {
+    decimals: 18,
+    nativeSymbol: "POL",
+    explorer: "https://polygonscan.com",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  8453: {
+    decimals: 18,
+    nativeSymbol: "ETH",
+    explorer: "https://basescan.org",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  42161: {
+    decimals: 18,
+    nativeSymbol: "ETH",
+    explorer: "https://arbiscan.io",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  11155111: {
+    decimals: 18,
+    nativeSymbol: "ETH",
+    explorer: "https://sepolia.etherscan.io",
+    base: {
+      "shared-control": 100000000000000n,
+      "commercial-tx": 1000000000000n
+    }
+  },
+  6623: {
+    decimals: 18,
+    nativeSymbol: "OMA",
+    explorer: "https://explorer.chain.oma3.org",
+    base: {
+      "shared-control": 10000000000000000n,
+      "commercial-tx": 100000000000000n
+    }
+  },
+  66238: {
+    decimals: 18,
+    nativeSymbol: "OMA",
+    explorer: "https://explorer.testnet.chain.oma3.org",
+    base: {
+      "shared-control": 10000000000000000n,
+      "commercial-tx": 100000000000000n
+    }
+  }
+};
+var AMOUNT_DOMAIN = "OMATrust:Amount:v1";
+function getConfig(chainId) {
+  const config = CHAIN_CONFIGS[chainId];
+  if (!config) {
+    throw new OmaTrustError("UNSUPPORTED_CHAIN", "Chain is not supported", {
+      chainId,
+      supported: getSupportedChainIds()
+    });
+  }
+  return config;
+}
+function getSupportedChainIds() {
+  return Object.keys(CHAIN_CONFIGS).map((id) => Number(id));
+}
+function isChainSupported(chainId) {
+  return chainId in CHAIN_CONFIGS;
+}
+function getChainConstants(chainId, purpose) {
+  const config = getConfig(chainId);
+  const base = config.base[purpose];
+  const range = base / 10n;
+  return {
+    base,
+    range,
+    decimals: config.decimals,
+    nativeSymbol: config.nativeSymbol
+  };
+}
+function constructSeed(subjectDidHash, counterpartyDidHash, purpose) {
+  const seed = {
+    domain: AMOUNT_DOMAIN,
+    subjectDidHash,
+    counterpartyIdHash: counterpartyDidHash,
+    proofPurpose: purpose
+  };
+  const canonical = canonicalize(seed);
+  if (!canonical) {
+    throw new OmaTrustError("INVALID_INPUT", "Failed to canonicalize seed");
+  }
+  return toUtf8Bytes(canonical);
+}
+function hashSeed(seedBytes, chainId) {
+  if (!isChainSupported(chainId)) {
+    throw new OmaTrustError("UNSUPPORTED_CHAIN", "Chain is not supported", { chainId });
+  }
+  if (chainId === 0) {
+    return sha256(seedBytes);
+  }
+  return keccak256(seedBytes);
+}
+function calculateTransferAmount(subject, counterparty, chainId, purpose) {
+  const { base, range } = getChainConstants(chainId, purpose);
+  const subjectDidHash = computeDidHash(subject);
+  const counterpartyDidHash = computeDidHash(counterparty);
+  const seed = constructSeed(subjectDidHash, counterpartyDidHash, purpose);
+  const hashed = hashSeed(seed, chainId);
+  const offset = BigInt(hashed) % range;
+  return base + offset;
+}
+function calculateTransferAmountFromAddresses(subjectAddress, counterpartyAddress, chainId, purpose) {
+  return calculateTransferAmount(
+    buildEvmDidPkh(chainId, subjectAddress),
+    buildEvmDidPkh(chainId, counterpartyAddress),
+    chainId,
+    purpose
+  );
+}
+function createTxEncodedValueProof(chainId, txHash, purpose) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(txHash)) {
+    throw new OmaTrustError("INVALID_INPUT", "txHash must be a 32-byte hex string", { txHash });
+  }
+  return {
+    proofType: "tx-encoded-value",
+    proofPurpose: purpose,
+    proofObject: {
+      chainId: `eip155:${chainId}`,
+      txHash
+    },
+    version: 1,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+function formatTransferAmount(amount, chainId) {
+  const config = getConfig(chainId);
+  const normalized = typeof amount === "number" ? BigInt(Math.floor(amount)) : amount;
+  return `${formatUnits(normalized, config.decimals)} ${config.nativeSymbol}`;
+}
+function getExplorerTxUrl(chainId, txHash) {
+  return `${getConfig(chainId).explorer}/tx/${txHash}`;
+}
+function getExplorerAddressUrl(chainId, address) {
+  return `${getConfig(chainId).explorer}/address/${address}`;
+}
+
+// src/reputation/proof/did-json.ts
+init_did();
+init_jwk();
+init_errors();
+
+// src/shared/did-document.ts
+init_errors();
+async function fetchDidDocument(domain) {
+  const normalized = domain.toLowerCase().replace(/\.$/, "");
+  const url = `https://${normalized}/.well-known/did.json`;
+  let response;
+  try {
+    response = await fetch(url, { headers: { Accept: "application/json" } });
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to fetch DID document", { domain, err });
+  }
+  if (!response.ok) {
+    throw new OmaTrustError("NETWORK_ERROR", `DID document fetch failed: ${response.status}`, {
+      domain,
+      status: response.status
+    });
+  }
+  return await response.json();
+}
+
+// src/reputation/proof/did-json.ts
+function extractEvmAddressesFromDidDocument(didDocument) {
+  const methods = didDocument.verificationMethod;
+  if (!Array.isArray(methods)) {
+    return [];
+  }
+  const addresses = /* @__PURE__ */ new Set();
+  for (const method of methods) {
+    const blockchainAccountId = method.blockchainAccountId;
+    if (typeof blockchainAccountId === "string") {
+      try {
+        addresses.add(getAddress(extractAddressFromDid(blockchainAccountId)));
+      } catch {
+      }
+    }
+    const publicKeyHex = method.publicKeyHex;
+    if (typeof publicKeyHex === "string") {
+      const prefixed = publicKeyHex.startsWith("0x") ? publicKeyHex : `0x${publicKeyHex}`;
+      if (isAddress(prefixed)) {
+        addresses.add(getAddress(prefixed));
+      }
+    }
+  }
+  return [...addresses];
+}
+function extractJwksFromDidDocument(didDocument) {
+  const methods = didDocument.verificationMethod;
+  if (!Array.isArray(methods)) {
+    return [];
+  }
+  const jwks = [];
+  for (const method of methods) {
+    const publicKeyJwk = method.publicKeyJwk;
+    if (publicKeyJwk && typeof publicKeyJwk === "object" && !Array.isArray(publicKeyJwk)) {
+      jwks.push(publicKeyJwk);
+    }
+  }
+  return jwks;
+}
+function verifyDidDocumentControllerDid(didDocument, expectedControllerDid) {
+  const method = extractDidMethod(expectedControllerDid);
+  if (method === "jwk") {
+    try {
+      const expectedJwk = didJwkToJwk(expectedControllerDid);
+      const documentJwks = extractJwksFromDidDocument(didDocument);
+      for (const docJwk of documentJwks) {
+        try {
+          if (publicJwkEquals(docJwk, expectedJwk)) {
+            return { valid: true };
+          }
+        } catch {
+        }
+      }
+      return {
+        valid: false,
+        reason: "No matching publicKeyJwk found in DID document verification methods"
+      };
+    } catch {
+      return {
+        valid: false,
+        reason: "Failed to decode did:jwk controller DID"
+      };
+    }
+  }
+  let expectedAddress;
+  try {
+    expectedAddress = getAddress(extractAddressFromDid(expectedControllerDid));
+  } catch {
+    return { valid: false, reason: "Controller DID does not resolve to an EVM address and is not did:jwk" };
+  }
+  const addresses = extractEvmAddressesFromDidDocument(didDocument);
+  if (addresses.some((address) => address.toLowerCase() === expectedAddress.toLowerCase())) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    reason: `No matching address found in DID document (expected ${expectedAddress})`
+  };
+}
+async function verifyDidJsonControllerDid(domain, expectedControllerDid, options = {}) {
+  if (!domain || typeof domain !== "string") {
+    throw new OmaTrustError("INVALID_INPUT", "domain must be a non-empty string", { domain });
+  }
+  const didDocument = options.fetchDidDocument ? await options.fetchDidDocument(domain) : await fetchDidDocument(domain);
+  return verifyDidDocumentControllerDid(didDocument, expectedControllerDid);
+}
+
+// src/reputation/proof/eip712.ts
+init_errors();
+function buildEip712Domain(name, version, chainId, verifyingContract) {
+  return { name, version, chainId, verifyingContract };
+}
+function getOmaTrustProofEip712Types() {
+  return {
+    primaryType: "OmaTrustProof",
+    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" }
+      ]
+    }
+  };
+}
+function verifyEip712Signature(typedData, signature) {
+  try {
+    const signer = verifyTypedData(
+      typedData.domain,
+      typedData.types,
+      typedData.message,
+      signature
+    );
+    return { valid: true, signer };
+  } catch (err) {
+    throw new OmaTrustError("INVALID_INPUT", "Failed to verify EIP-712 signature", { err });
+  }
+}
+
+// src/reputation/verify.ts
+init_dns_txt_record();
+
+// src/reputation/proof/x402-jws.ts
+init_errors();
+init_jwk();
+
+// src/identity/resolve-key.ts
+init_errors();
+init_assert();
+
+// src/identity/did-url.ts
+init_errors();
+init_assert();
+var DID_URL_REGEX = /^did:[a-z0-9]+:.+$/i;
+function parseDidUrl(input) {
+  assertString(input, "input", "INVALID_DID_URL");
+  const trimmed = input.trim();
+  const hashIndex = trimmed.indexOf("#");
+  let did;
+  let fragment;
+  if (hashIndex === -1) {
+    did = trimmed;
+    fragment = null;
+  } else {
+    did = trimmed.slice(0, hashIndex);
+    const rawFragment = trimmed.slice(hashIndex + 1);
+    if (rawFragment.length === 0) {
+      throw new OmaTrustError(
+        "INVALID_DID_URL",
+        "DID URL has empty fragment (trailing '#' with no identifier)",
+        { input }
+      );
+    }
+    fragment = rawFragment;
+  }
+  if (!DID_URL_REGEX.test(did)) {
+    throw new OmaTrustError(
+      "INVALID_DID_URL",
+      "Invalid DID URL: base DID portion is malformed",
+      { input, did }
+    );
+  }
+  return {
+    didUrl: trimmed,
+    did,
+    fragment
+  };
+}
+
+// src/identity/resolve-key.ts
+init_did();
+init_jwk();
+function findVerificationMethod(didDocument, didUrl, fragment) {
+  const methods = didDocument.verificationMethod;
+  if (!Array.isArray(methods)) {
+    return null;
+  }
+  for (const method of methods) {
+    if (!method || typeof method !== "object") continue;
+    const id = method.id;
+    if (typeof id !== "string") continue;
+    if (id === didUrl) return method;
+    if (fragment && (id === `#${fragment}` || id.endsWith(`#${fragment}`))) {
+      return method;
+    }
+  }
+  return null;
+}
+function extractMethodIdsFromDidDocument(didDocument) {
+  const methods = didDocument.verificationMethod;
+  if (!Array.isArray(methods)) return [];
+  return methods.filter((m) => m && typeof m.id === "string").map((m) => m.id);
+}
+async function resolveDidUrlToPublicKey(didUrl, options) {
+  assertString(didUrl, "didUrl", "INVALID_DID_URL");
+  const parsed = parseDidUrl(didUrl);
+  const method = extractDidMethod(parsed.did);
+  if (!method) {
+    throw new OmaTrustError("INVALID_DID_URL", "Cannot extract DID method from DID URL", {
+      didUrl,
+      did: parsed.did
+    });
+  }
+  switch (method) {
+    case "web":
+      return resolveDidUrlKey(parsed.didUrl, parsed.did, parsed.fragment);
+    default:
+      throw new OmaTrustError(
+        "UNSUPPORTED_DID_METHOD",
+        `DID URL key resolution is not supported for method "${method}"`,
+        { didUrl, method }
+      );
+  }
+}
+async function resolveDidUrlKey(didUrl, did, fragment, options) {
+  const domain = getDomainFromDidWeb(did);
+  if (!domain) {
+    throw new OmaTrustError("INVALID_DID_URL", "Cannot extract domain from did:web DID", {
+      didUrl,
+      did
+    });
+  }
+  const fetchFn = fetchDidDocument;
+  const didDocument = await fetchFn(domain);
+  const method = findVerificationMethod(didDocument, didUrl, fragment);
+  if (!method) {
+    throw new OmaTrustError(
+      "KEY_NOT_FOUND",
+      `No verification method found matching "${fragment ? `#${fragment}` : didUrl}"`,
+      { didUrl, fragment, availableMethods: extractMethodIdsFromDidDocument(didDocument) }
+    );
+  }
+  const publicKeyJwk = method.publicKeyJwk;
+  if (!publicKeyJwk || typeof publicKeyJwk !== "object") {
+    throw new OmaTrustError(
+      "KEY_NOT_FOUND",
+      `Verification method "${method.id}" does not contain publicKeyJwk`,
+      { didUrl, verificationMethodId: method.id }
+    );
+  }
+  const validation = validatePublicJwk(publicKeyJwk);
+  if (!validation.valid) {
+    throw new OmaTrustError(
+      "INVALID_JWK",
+      `publicKeyJwk in verification method "${method.id}" is invalid: ${validation.error}`,
+      { didUrl, verificationMethodId: method.id }
+    );
+  }
+  return {
+    didUrl,
+    did,
+    fragment,
+    publicKeyJwk,
+    verificationMethodId: method.id
+  };
+}
+
+// src/reputation/proof/x402-jws.ts
+var REQUIRED_OFFER_FIELDS = [
+  "version",
+  "resourceUrl",
+  "scheme",
+  "network",
+  "asset",
+  "payTo",
+  "amount"
+];
+var REQUIRED_RECEIPT_FIELDS = [
+  "version",
+  "network",
+  "resourceUrl",
+  "payer",
+  "issuedAt"
+];
+function validateOfferPayload(payload) {
+  for (const field of REQUIRED_OFFER_FIELDS) {
+    if (!(field in payload) || payload[field] === void 0 || payload[field] === null) {
+      return { valid: false, field };
+    }
+  }
+  return { valid: true };
+}
+function validateReceiptPayload(payload) {
+  for (const field of REQUIRED_RECEIPT_FIELDS) {
+    if (!(field in payload) || payload[field] === void 0 || payload[field] === null) {
+      return { valid: false, field };
+    }
+  }
+  return { valid: true };
+}
+function failure(code, message, partial) {
+  return {
+    valid: false,
+    error: { code, message },
+    ...partial
+  };
+}
+async function verifyX402JwsArtifact(artifact, options) {
+  if (!artifact || typeof artifact !== "object") {
+    return failure("INVALID_ARTIFACT", "Artifact must be a non-null object");
+  }
+  if (artifact.format !== "jws") {
+    return failure("INVALID_ARTIFACT", `Expected format "jws", got "${artifact.format}"`);
+  }
+  if (typeof artifact.signature !== "string" || artifact.signature.length === 0) {
+    return failure("INVALID_ARTIFACT", "Artifact signature must be a non-empty string");
+  }
+  const compactJws = artifact.signature;
+  const parts = compactJws.split(".");
+  if (parts.length !== 3) {
+    return failure("MALFORMED_JWS", "Invalid compact JWS format: expected 3 dot-separated parts");
+  }
+  let header;
+  try {
+    header = decodeProtectedHeader(compactJws);
+  } catch {
+    return failure("MALFORMED_JWS", "Failed to decode JWS protected header");
+  }
+  if (!header.alg || typeof header.alg !== "string") {
+    return failure("MISSING_ALG", "JWS header must include alg", { header });
+  }
+  const kid = typeof header.kid === "string" ? header.kid : null;
+  const embeddedJwk = header.jwk;
+  if (!kid && !embeddedJwk) {
+    return failure(
+      "MISSING_KEY_MATERIAL",
+      "JWS header must include at least one of kid or jwk",
+      { header }
+    );
+  }
+  let publicKeyJwk;
+  let publicKeySource;
+  if (embeddedJwk) {
+    const validation = validatePublicJwk(embeddedJwk);
+    if (!validation.valid) {
+      return failure(
+        "INVALID_EMBEDDED_JWK",
+        `Embedded JWK is invalid: ${validation.error}`,
+        { header }
+      );
+    }
+    publicKeyJwk = embeddedJwk;
+    publicKeySource = "embedded-jwk";
+    if (kid) {
+      try {
+        const resolved = await resolveDidUrlToPublicKey(kid, options?.resolveOptions);
+        if (!publicJwkEquals(publicKeyJwk, resolved.publicKeyJwk)) {
+          return failure(
+            "KEY_CONFLICT",
+            "Embedded jwk conflicts with public key resolved from kid",
+            { header, kid }
+          );
+        }
+      } catch (err) {
+      }
+    }
+  } else {
+    publicKeySource = "kid-resolution";
+    try {
+      const resolved = await resolveDidUrlToPublicKey(kid, options?.resolveOptions);
+      publicKeyJwk = resolved.publicKeyJwk;
+    } catch (err) {
+      const message = err instanceof OmaTrustError ? `Failed to resolve kid "${kid}": ${err.message}` : `Failed to resolve kid "${kid}"`;
+      return failure("KID_RESOLUTION_FAILED", message, { header, kid });
+    }
+  }
+  let payload;
+  try {
+    const key = await importJWK(publicKeyJwk, header.alg);
+    const result = await compactVerify(compactJws, key);
+    const payloadText = new TextDecoder().decode(result.payload);
+    payload = JSON.parse(payloadText);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Signature verification failed";
+    return failure("SIGNATURE_INVALID", message, { header, kid });
+  }
+  const publicKeyDid = jwkToDidJwk(publicKeyJwk);
+  return {
+    valid: true,
+    header,
+    payload,
+    kid,
+    publicKeyJwk,
+    publicKeySource,
+    publicKeyDid
+  };
+}
+async function verifyX402JwsOffer(artifact, options) {
+  const result = await verifyX402JwsArtifact(artifact, options);
+  if (!result.valid) return result;
+  const payloadCheck = validateOfferPayload(result.payload);
+  if (!payloadCheck.valid) {
+    return failure(
+      "INVALID_OFFER_PAYLOAD",
+      `Missing required offer field: ${payloadCheck.field}`,
+      {
+        header: result.header,
+        payload: result.payload,
+        kid: result.kid,
+        publicKeyJwk: result.publicKeyJwk,
+        publicKeySource: result.publicKeySource,
+        publicKeyDid: result.publicKeyDid
+      }
+    );
+  }
+  return result;
+}
+async function verifyX402JwsReceipt(artifact, options) {
+  const result = await verifyX402JwsArtifact(artifact, options);
+  if (!result.valid) return result;
+  const payloadCheck = validateReceiptPayload(result.payload);
+  if (!payloadCheck.valid) {
+    return failure(
+      "INVALID_RECEIPT_PAYLOAD",
+      `Missing required receipt field: ${payloadCheck.field}`,
+      {
+        header: result.header,
+        payload: result.payload,
+        kid: result.kid,
+        publicKeyJwk: result.publicKeyJwk,
+        publicKeySource: result.publicKeySource,
+        publicKeyDid: result.publicKeyDid
+      }
+    );
+  }
+  return result;
+}
+var OFFER_DOMAIN = {
+  name: "x402 offer",
+  version: "1",
+  chainId: 1
+};
+var RECEIPT_DOMAIN = {
+  name: "x402 receipt",
+  version: "1",
+  chainId: 1
+};
+var OFFER_TYPES = {
+  Offer: [
+    { name: "version", type: "uint256" },
+    { name: "resourceUrl", type: "string" },
+    { name: "scheme", type: "string" },
+    { name: "network", type: "string" },
+    { name: "asset", type: "string" },
+    { name: "payTo", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "validUntil", type: "uint256" }
+  ]
+};
+var RECEIPT_TYPES = {
+  Receipt: [
+    { name: "version", type: "uint256" },
+    { name: "network", type: "string" },
+    { name: "resourceUrl", type: "string" },
+    { name: "payer", type: "string" },
+    { name: "issuedAt", type: "uint256" },
+    { name: "transaction", type: "string" }
+  ]
+};
+var REQUIRED_OFFER_FIELDS2 = [
+  "version",
+  "resourceUrl",
+  "scheme",
+  "network",
+  "asset",
+  "payTo",
+  "amount"
+];
+var REQUIRED_RECEIPT_FIELDS2 = [
+  "version",
+  "network",
+  "resourceUrl",
+  "payer",
+  "issuedAt"
+];
+function validateOfferPayload2(payload) {
+  for (const field of REQUIRED_OFFER_FIELDS2) {
+    if (!(field in payload) || payload[field] === void 0 || payload[field] === null) {
+      return { valid: false, field };
+    }
+  }
+  return { valid: true };
+}
+function validateReceiptPayload2(payload) {
+  for (const field of REQUIRED_RECEIPT_FIELDS2) {
+    if (!(field in payload) || payload[field] === void 0 || payload[field] === null) {
+      return { valid: false, field };
+    }
+  }
+  return { valid: true };
+}
+function failure2(code, message, partial) {
+  return {
+    valid: false,
+    error: { code, message },
+    ...partial
+  };
+}
+function prepareOfferMessage(payload) {
+  return {
+    version: payload.version,
+    resourceUrl: payload.resourceUrl,
+    scheme: payload.scheme,
+    network: payload.network,
+    asset: payload.asset,
+    payTo: payload.payTo,
+    amount: payload.amount,
+    validUntil: payload.validUntil ?? 0
+  };
+}
+function prepareReceiptMessage(payload) {
+  return {
+    version: payload.version,
+    network: payload.network,
+    resourceUrl: payload.resourceUrl,
+    payer: payload.payer,
+    issuedAt: payload.issuedAt,
+    transaction: payload.transaction ?? ""
+  };
+}
+function verifyX402Eip712Artifact(artifact, artifactType) {
+  if (!artifact || typeof artifact !== "object") {
+    return failure2("INVALID_ARTIFACT", "Artifact must be a non-null object");
+  }
+  if (artifact.format !== "eip712") {
+    return failure2("INVALID_ARTIFACT", `Expected format "eip712", got "${artifact.format}"`);
+  }
+  if (!artifact.payload || typeof artifact.payload !== "object" || Array.isArray(artifact.payload)) {
+    return failure2("MISSING_PAYLOAD", "EIP-712 artifact must include a payload object");
+  }
+  if (typeof artifact.signature !== "string" || artifact.signature.length === 0) {
+    return failure2("MISSING_SIGNATURE", "EIP-712 artifact must include a non-empty signature");
+  }
+  const payload = artifact.payload;
+  if (artifactType === "offer") {
+    const check = validateOfferPayload2(payload);
+    if (!check.valid) {
+      return failure2(
+        "INVALID_OFFER_PAYLOAD",
+        `Missing required offer field: ${check.field}`,
+        { payload }
+      );
+    }
+  } else {
+    const check = validateReceiptPayload2(payload);
+    if (!check.valid) {
+      return failure2(
+        "INVALID_RECEIPT_PAYLOAD",
+        `Missing required receipt field: ${check.field}`,
+        { payload }
+      );
+    }
+  }
+  const domain = artifactType === "offer" ? OFFER_DOMAIN : RECEIPT_DOMAIN;
+  const types = artifactType === "offer" ? OFFER_TYPES : RECEIPT_TYPES;
+  const message = artifactType === "offer" ? prepareOfferMessage(payload) : prepareReceiptMessage(payload);
+  let signer;
+  try {
+    signer = verifyTypedData(
+      domain,
+      types,
+      message,
+      artifact.signature
+    );
+    signer = getAddress(signer);
+  } catch (err) {
+    const message2 = err instanceof Error ? err.message : "EIP-712 signature verification failed";
+    return failure2("SIGNATURE_INVALID", message2, { payload });
+  }
+  return {
+    valid: true,
+    payload,
+    signer,
+    artifactType
+  };
+}
+function verifyX402Eip712Offer(artifact) {
+  return verifyX402Eip712Artifact(artifact, "offer");
+}
+function verifyX402Eip712Receipt(artifact) {
+  return verifyX402Eip712Artifact(artifact, "receipt");
+}
+
+// src/reputation/verify.ts
+function parseChainId(input) {
+  if (typeof input === "number") {
+    return input;
+  }
+  if (typeof input === "string") {
+    if (input.includes(":")) {
+      const [, chainId] = input.split(":");
+      return Number(chainId);
+    }
+    return Number(input);
+  }
+  return NaN;
+}
+function parseProofs(attestation) {
+  const rawProofs = attestation.data.proofs;
+  if (!Array.isArray(rawProofs)) {
+    return [];
+  }
+  return rawProofs.map((entry) => {
+    if (typeof entry === "string") {
+      try {
+        return JSON.parse(entry);
+      } catch {
+        return null;
+      }
+    }
+    if (entry && typeof entry === "object") {
+      return entry;
+    }
+    return null;
+  }).filter((proof) => Boolean(proof?.proofType));
+}
+function getProofPurpose(proof) {
+  if (proof.proofPurpose === "commercial-tx") {
+    return "commercial-tx";
+  }
+  return "shared-control";
+}
+function decodeJwtPayload(compactJws) {
+  const parts = compactJws.split(".");
+  if (parts.length !== 3) {
+    throw new OmaTrustError("PROOF_VERIFICATION_FAILED", "Invalid compact JWS format");
+  }
+  const payloadB64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+  const padded = payloadB64.padEnd(payloadB64.length + (4 - payloadB64.length % 4) % 4, "=");
+  let json;
+  if (typeof atob === "function") {
+    json = decodeURIComponent(
+      Array.from(atob(padded)).map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, "0")}`).join("")
+    );
+  } else {
+    json = Buffer.from(padded, "base64").toString("utf8");
+  }
+  return JSON.parse(json);
+}
+async function verifyProof(params) {
+  const { proof, provider, expectedSubjectDid, expectedControllerDid } = params;
+  try {
+    switch (proof.proofType) {
+      case "tx-encoded-value": {
+        if (!provider) {
+          return { valid: false, proofType: proof.proofType, reason: "Provider is required" };
+        }
+        if (!expectedSubjectDid || !expectedControllerDid) {
+          return {
+            valid: false,
+            proofType: proof.proofType,
+            reason: "expectedSubjectDid and expectedControllerDid are required"
+          };
+        }
+        const proofObject = proof.proofObject;
+        const chainId = parseChainId(proofObject.chainId);
+        const tx = await provider.getTransaction(
+          proofObject.txHash
+        );
+        if (!tx) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction not found" };
+        }
+        const expectedAmount = calculateTransferAmount(
+          expectedSubjectDid,
+          expectedControllerDid,
+          chainId,
+          getProofPurpose(proof)
+        );
+        const subjectAddress = getAddress(extractAddressFromDid(expectedSubjectDid));
+        const controllerAddress = getAddress(extractAddressFromDid(expectedControllerDid));
+        if (tx.from && getAddress(tx.from) !== subjectAddress) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction sender mismatch" };
+        }
+        if (tx.to && getAddress(tx.to) !== controllerAddress) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction recipient mismatch" };
+        }
+        if (BigInt(tx.value) !== expectedAmount) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction amount mismatch" };
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      case "tx-interaction": {
+        if (!provider) {
+          return { valid: false, proofType: proof.proofType, reason: "Provider is required" };
+        }
+        const proofObject = proof.proofObject;
+        const tx = await provider.getTransaction(
+          proofObject.txHash
+        );
+        if (!tx) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction not found" };
+        }
+        if (!tx.to) {
+          return { valid: false, proofType: proof.proofType, reason: "Transaction target missing" };
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      case "pop-eip712": {
+        const object = proof.proofObject;
+        const typedData = {
+          domain: object.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: object.message
+        };
+        const verification = verifyEip712Signature(typedData, object.signature);
+        if (!verification.valid || !verification.signer) {
+          return { valid: false, proofType: proof.proofType, reason: "Invalid EIP-712 signature" };
+        }
+        if (typeof object.message.signer === "string") {
+          const expected = getAddress(object.message.signer);
+          if (getAddress(verification.signer) !== expected) {
+            return { valid: false, proofType: proof.proofType, reason: "Recovered signer mismatch" };
+          }
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      case "pop-jws": {
+        if (typeof proof.proofObject !== "string") {
+          return { valid: false, proofType: proof.proofType, reason: "Invalid JWS proof payload" };
+        }
+        const payload = decodeJwtPayload(proof.proofObject);
+        const now = Math.floor(Date.now() / 1e3);
+        const exp = payload.exp;
+        if (typeof exp === "number" && exp < now) {
+          return { valid: false, proofType: proof.proofType, reason: "JWS proof expired" };
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      case "x402-receipt":
+      case "x402-offer": {
+        if (!proof.proofObject || typeof proof.proofObject !== "object") {
+          return { valid: false, proofType: proof.proofType, reason: "Invalid x402 proof object" };
+        }
+        const proofObj = proof.proofObject;
+        if (proofObj.format === "jws" && typeof proofObj.signature === "string") {
+          const artifact = {
+            format: "jws",
+            signature: proofObj.signature
+          };
+          const jwsResult = proof.proofType === "x402-offer" ? await verifyX402JwsOffer(artifact) : await verifyX402JwsReceipt(artifact);
+          if (!jwsResult.valid) {
+            return {
+              valid: false,
+              proofType: proof.proofType,
+              reason: jwsResult.error?.message ?? "JWS verification failed"
+            };
+          }
+          return { valid: true, proofType: proof.proofType };
+        }
+        if (proofObj.format === "eip712" && typeof proofObj.signature === "string" && proofObj.payload && typeof proofObj.payload === "object") {
+          const artifact = {
+            format: "eip712",
+            payload: proofObj.payload,
+            signature: proofObj.signature
+          };
+          const eip712Result = proof.proofType === "x402-offer" ? verifyX402Eip712Offer(artifact) : verifyX402Eip712Receipt(artifact);
+          if (!eip712Result.valid) {
+            return {
+              valid: false,
+              proofType: proof.proofType,
+              reason: eip712Result.error?.message ?? "EIP-712 verification failed"
+            };
+          }
+          return { valid: true, proofType: proof.proofType };
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      case "evidence-pointer": {
+        const object = proof.proofObject;
+        if (!object.url) {
+          return { valid: false, proofType: proof.proofType, reason: "Missing evidence URL" };
+        }
+        const response = await fetch(object.url);
+        if (!response.ok) {
+          return { valid: false, proofType: proof.proofType, reason: `Evidence fetch failed (${response.status})` };
+        }
+        if (object.url.endsWith("/.well-known/did.json") && expectedControllerDid) {
+          const didDoc = await response.json();
+          const didCheck = verifyDidDocumentControllerDid(didDoc, expectedControllerDid);
+          return {
+            valid: didCheck.valid,
+            proofType: proof.proofType,
+            reason: didCheck.reason
+          };
+        }
+        const body = await response.text();
+        if (expectedControllerDid && !body.includes(expectedControllerDid)) {
+          try {
+            const parsed = parseDnsTxtRecord(body);
+            if (!parsed.controllers.includes(expectedControllerDid)) {
+              return {
+                valid: false,
+                proofType: proof.proofType,
+                reason: "Evidence does not include expected controller DID"
+              };
+            }
+          } catch {
+            return {
+              valid: false,
+              proofType: proof.proofType,
+              reason: "Evidence does not include expected controller DID"
+            };
+          }
+        }
+        return { valid: true, proofType: proof.proofType };
+      }
+      default:
+        return { valid: false, proofType: proof.proofType, reason: "Unsupported proof type" };
+    }
+  } catch (err) {
+    throw new OmaTrustError("PROOF_VERIFICATION_FAILED", "Proof verification failed", {
+      proofType: proof.proofType,
+      err
+    });
+  }
+}
+async function verifyAttestation(params) {
+  const proofs = parseProofs(params.attestation);
+  const checks = {};
+  const reasons = [];
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  if (params.attestation.revocationTime > 0n) {
+    checks.revocation = false;
+    reasons.push("attestation revoked");
+  } else {
+    checks.revocation = true;
+  }
+  if (params.attestation.expirationTime > 0n && params.attestation.expirationTime < now) {
+    checks.expiration = false;
+    reasons.push("attestation expired");
+  } else {
+    checks.expiration = true;
+  }
+  if (proofs.length === 0) {
+    checks.proofs = false;
+    reasons.push("no proofs provided");
+  }
+  const selectedProofTypes = params.checks ?? proofs.map((proof) => proof.proofType);
+  for (const proof of proofs) {
+    if (!selectedProofTypes.includes(proof.proofType)) {
+      continue;
+    }
+    const result = await verifyProof({
+      proof,
+      provider: params.provider,
+      expectedSubjectDid: params.context?.subjectDid,
+      expectedControllerDid: params.context?.controllerDid
+    });
+    checks[proof.proofType] = result.valid;
+    if (!result.valid) {
+      reasons.push(result.reason ?? `${proof.proofType} verification failed`);
+    }
+  }
+  return {
+    valid: reasons.length === 0,
+    checks,
+    reasons
+  };
+}
+
+// src/reputation/schema.ts
+init_errors();
+async function verifySchemaExists(schemaRegistry, schemaUid) {
+  const registry = schemaRegistry;
+  try {
+    const schema = await registry.getSchema({ uid: schemaUid });
+    return Boolean(schema && schema.uid && schema.uid !== "0x".padEnd(66, "0"));
+  } catch {
+    return false;
+  }
+}
+async function getSchemaDetails(schemaRegistry, schemaUid) {
+  const registry = schemaRegistry;
+  try {
+    const details = await registry.getSchema({ uid: schemaUid });
+    if (!details || !details.uid || details.uid === "0x".padEnd(66, "0")) {
+      throw new OmaTrustError("SCHEMA_NOT_FOUND", "Schema was not found", { schemaUid });
+    }
+    return {
+      uid: formatSchemaUid(details.uid),
+      schema: details.schema,
+      resolver: details.resolver,
+      revocable: Boolean(details.revocable)
+    };
+  } catch (err) {
+    if (isEasSchemaNotFoundError(err)) {
+      throw new OmaTrustError("SCHEMA_NOT_FOUND", "Schema was not found", { schemaUid });
+    }
+    if (err instanceof OmaTrustError) {
+      throw err;
+    }
+    throw new OmaTrustError("NETWORK_ERROR", "Failed to read schema details", { schemaUid, err });
+  }
+}
+function formatSchemaUid(schemaUid) {
+  if (!schemaUid) {
+    throw new OmaTrustError("INVALID_INPUT", "schemaUid is required");
+  }
+  const value = schemaUid.startsWith("0x") ? schemaUid.toLowerCase() : `0x${schemaUid.toLowerCase()}`;
+  if (!/^0x[0-9a-f]{64}$/.test(value)) {
+    throw new OmaTrustError("INVALID_INPUT", "schemaUid must be a 32-byte hex string", { schemaUid });
+  }
+  return value;
+}
+
+// src/reputation/witness.ts
+init_errors();
+async function callMethod(params, method) {
+  let response;
+  try {
+    response = await fetch(params.gatewayUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        attestationUid: params.attestationUid,
+        chainId: params.chainId,
+        easContract: params.easContract,
+        schemaUid: params.schemaUid,
+        subject: params.subject,
+        controller: params.controller,
+        method
+      }),
+      signal: AbortSignal.timeout(params.timeoutMs ?? 15e3)
+    });
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Controller witness request failed", { method, err });
+  }
+  const details = await response.json().catch(() => void 0);
+  if (!response.ok) {
+    return null;
+  }
+  return {
+    ok: true,
+    method,
+    details
+  };
+}
+async function callControllerWitness(params) {
+  const dnsResult = await callMethod(params, "dns-txt").catch(() => null);
+  if (dnsResult) {
+    return dnsResult;
+  }
+  const didJsonResult = await callMethod(params, "did-json").catch(() => null);
+  if (didJsonResult) {
+    return didJsonResult;
+  }
+  return {
+    ok: false,
+    method: "did-json"
+  };
+}
+var DEFAULT_CONTROLLER_WITNESS_URL = "https://api.omatrust.org/v1/controller-witness";
+async function requestControllerWitness(params) {
+  const url = params.gatewayUrl ?? DEFAULT_CONTROLLER_WITNESS_URL;
+  const body = {
+    subjectDid: params.subjectDid,
+    controllerDid: params.controllerDid
+  };
+  if (params.chainId !== void 0) {
+    body.chainId = params.chainId;
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(params.timeoutMs ?? 15e3)
+    });
+  } catch (err) {
+    throw new OmaTrustError("NETWORK_ERROR", "Controller witness request failed", { err });
+  }
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({ error: response.statusText }));
+    throw new OmaTrustError(
+      "API_ERROR",
+      errorBody.error ?? `Controller witness failed: ${response.status}`,
+      { status: response.status, ...errorBody }
+    );
+  }
+  return await response.json();
+}
+
+// src/reputation/proof/tx-interaction.ts
+init_errors();
+function createTxInteractionProof(chainId, txHash) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(txHash)) {
+    throw new OmaTrustError("INVALID_INPUT", "txHash must be a 32-byte hex string", { txHash });
+  }
+  return {
+    proofType: "tx-interaction",
+    proofPurpose: "commercial-tx",
+    proofObject: {
+      chainId: `eip155:${chainId}`,
+      txHash
+    },
+    version: 1,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+
+// src/reputation/proof/pop-eip712.ts
+init_errors();
+async function createPopEip712Proof(params, signFn) {
+  if (!params.signer || !params.authorizedEntity) {
+    throw new OmaTrustError("INVALID_INPUT", "signer and authorizedEntity are required", { params });
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const creationTimestamp = params.creationTimestamp ?? now;
+  const expirationTimestamp = params.expirationTimestamp ?? now + 600;
+  const randomValue = params.randomValue ?? hexlify(randomBytes(32));
+  const message = {
+    signer: params.signer,
+    authorizedEntity: params.authorizedEntity,
+    signingPurpose: params.signingPurpose,
+    creationTimestamp,
+    expirationTimestamp,
+    randomValue,
+    statement: params.statement ?? "This is not a transaction or asset approval."
+  };
+  const { types, primaryType } = getOmaTrustProofEip712Types();
+  const typedData = {
+    domain: {
+      name: "OMATrust Proof",
+      version: "1",
+      chainId: params.chainId
+    },
+    types,
+    primaryType,
+    message
+  };
+  const signature = await signFn(typedData);
+  return {
+    proofType: "pop-eip712",
+    proofObject: {
+      domain: typedData.domain,
+      message,
+      signature
+    },
+    version: 1,
+    issuedAt: creationTimestamp,
+    expiresAt: expirationTimestamp
+  };
+}
+
+// src/reputation/proof/pop-jws.ts
+init_errors();
+async function createPopJwsProof(params, signFn) {
+  if (!params.issuer || !params.audience) {
+    throw new OmaTrustError("INVALID_INPUT", "issuer and audience are required", { params });
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const payload = {
+    iss: params.issuer,
+    aud: params.audience,
+    purpose: params.purpose,
+    iat: params.issuedAt ?? now,
+    exp: params.expiresAt ?? now + 600,
+    nonce: params.nonce ?? (globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : `${Date.now()}-${Math.random()}`)
+  };
+  const header = {
+    typ: "JWT",
+    alg: "ES256K"
+  };
+  const jws = await signFn(payload, header);
+  return {
+    proofType: "pop-jws",
+    proofObject: jws,
+    proofPurpose: params.purpose,
+    version: 1,
+    issuedAt: payload.iat,
+    expiresAt: payload.exp
+  };
+}
+
+// src/reputation/proof/x402.ts
+function createX402ReceiptProof(receipt) {
+  return {
+    proofType: "x402-receipt",
+    proofPurpose: "commercial-tx",
+    proofObject: receipt,
+    version: 1,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+function createX402OfferProof(offer) {
+  return {
+    proofType: "x402-offer",
+    proofPurpose: "commercial-tx",
+    proofObject: offer,
+    version: 1,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+
+// src/reputation/proof/evidence-pointer.ts
+init_errors();
+function createEvidencePointerProof(url) {
+  if (!url || typeof url !== "string") {
+    throw new OmaTrustError("INVALID_INPUT", "url must be a non-empty string", { url });
+  }
+  return {
+    proofType: "evidence-pointer",
+    proofPurpose: "shared-control",
+    proofObject: { url },
+    version: 1,
+    issuedAt: Math.floor(Date.now() / 1e3)
+  };
+}
+
+// src/reputation/proof/dns-txt.browser.ts
+init_errors();
+init_dns_txt_record();
+async function verifyDnsTxtControllerDid2(domain, expectedControllerDid, options = {}) {
+  if (options.resolveTxt) {
+    const { verifyDnsTxtControllerDid: verifyWithResolver } = await Promise.resolve().then(() => (init_dns_txt_shared(), dns_txt_shared_exports));
+    return verifyWithResolver(domain, expectedControllerDid, options);
+  }
+  throw new OmaTrustError(
+    "NETWORK_ERROR",
+    "verifyDnsTxtControllerDid is not available in browser runtimes",
+    {
+      domain,
+      expectedControllerDid
+    }
+  );
+}
+
+// src/reputation/subject-ownership.ts
+init_did();
+init_errors();
+init_dns_txt_shared();
+
+// src/reputation/contract-ownership.ts
+init_did();
+var EIP1967_ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+var OWNERSHIP_PATTERNS = [
+  { method: "owner", signature: "function owner() view returns (address)" },
+  { method: "admin", signature: "function admin() view returns (address)" },
+  { method: "getOwner", signature: "function getOwner() view returns (address)" }
+];
+async function readOwnerFromContract(provider, contractAddress, signature, method) {
+  try {
+    const iface = new Interface([signature]);
+    const data = iface.encodeFunctionData(method, []);
+    const result = await provider.call({ to: contractAddress, data });
+    const [value] = iface.decodeFunctionResult(method, result);
+    if (typeof value === "string" && isAddress(value) && value !== ZeroAddress) {
+      return getAddress(value);
+    }
+  } catch {
+  }
+  return null;
+}
+async function discoverContractOwner(provider, contractAddress) {
+  try {
+    const code = await provider.getCode(contractAddress);
+    if (code === "0x" || code === "0x0") {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  for (const pattern of OWNERSHIP_PATTERNS) {
+    const address = await readOwnerFromContract(
+      provider,
+      contractAddress,
+      pattern.signature,
+      pattern.method
+    );
+    if (address) {
+      return address;
+    }
+  }
+  try {
+    const adminValue = await provider.getStorage(contractAddress, EIP1967_ADMIN_SLOT);
+    if (adminValue && adminValue !== "0x" && adminValue !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+      const adminAddress = getAddress(`0x${adminValue.slice(-40)}`);
+      if (adminAddress !== ZeroAddress) {
+        return adminAddress;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function discoverControllingWalletDid(provider, contractAddress, chainId) {
+  const owner = await discoverContractOwner(provider, contractAddress);
+  return owner ? buildEvmDidPkh(chainId, owner) : null;
+}
+
+// src/reputation/subject-ownership.ts
+function assertConnectedWalletDid(input) {
+  const normalized = normalizeDid(input);
+  if (extractDidMethod(normalized) !== "pkh") {
+    throw new OmaTrustError("INVALID_INPUT", "connectedWalletDid must be a did:pkh DID", {
+      connectedWalletDid: input
+    });
+  }
+  return normalized;
+}
+function normalizeSubjectDid(input) {
+  return normalizeDid(input);
+}
+async function verifyDidWebOwnership(params) {
+  const subjectDid = normalizeSubjectDid(params.subjectDid);
+  const connectedWalletDid = assertConnectedWalletDid(params.connectedWalletDid);
+  const domain = getDomainFromDidWeb(subjectDid);
+  if (!domain) {
+    throw new OmaTrustError("INVALID_INPUT", "subjectDid must be a did:web DID", {
+      subjectDid: params.subjectDid
+    });
+  }
+  let dnsReason;
+  try {
+    const dnsResult = await verifyDnsTxtControllerDid(domain, connectedWalletDid, {
+      resolveTxt: params.resolveTxt,
+      recordPrefix: params.recordPrefix
+    });
+    if (dnsResult.valid) {
+      return {
+        valid: true,
+        method: "dns",
+        details: `Verified via DNS TXT record at ${params.recordPrefix ?? "_controllers"}.${domain}`,
+        subjectDid,
+        connectedWalletDid
+      };
+    }
+    dnsReason = dnsResult.reason;
+  } catch (error) {
+    dnsReason = error instanceof Error ? error.message : "DNS TXT verification failed";
+  }
+  let didDocReason;
+  try {
+    const didDocumentResult = await verifyDidJsonControllerDid(domain, connectedWalletDid, {
+      fetchDidDocument: params.fetchDidDocument
+    });
+    if (didDocumentResult.valid) {
+      return {
+        valid: true,
+        method: "did-document",
+        details: `Verified via DID document at https://${domain}/.well-known/did.json`,
+        subjectDid,
+        connectedWalletDid
+      };
+    }
+    didDocReason = didDocumentResult.reason;
+  } catch (error) {
+    didDocReason = error instanceof Error ? error.message : "DID document verification failed";
+  }
+  return {
+    valid: false,
+    reason: "DID ownership verification failed",
+    details: `DNS check: ${dnsReason ?? "failed"}. DID document check: ${didDocReason ?? "failed"}.`,
+    subjectDid,
+    connectedWalletDid
+  };
+}
+async function verifyDidPkhOwnership(params) {
+  const subjectDid = normalizeSubjectDid(params.subjectDid);
+  const connectedWalletDid = assertConnectedWalletDid(params.connectedWalletDid);
+  if (!isEvmDidPkh(subjectDid)) {
+    throw new OmaTrustError("INVALID_INPUT", "subjectDid must be an EVM did:pkh DID", {
+      subjectDid: params.subjectDid
+    });
+  }
+  const subjectAddress = getAddressFromDidPkh(subjectDid);
+  const connectedWalletAddress = getAddressFromDidPkh(connectedWalletDid);
+  const chainIdRaw = getChainIdFromDidPkh(subjectDid);
+  if (!subjectAddress || !connectedWalletAddress || !chainIdRaw) {
+    throw new OmaTrustError("INVALID_INPUT", "Could not parse did:pkh ownership inputs", {
+      subjectDid: params.subjectDid,
+      connectedWalletDid: params.connectedWalletDid
+    });
+  }
+  const chainId = Number(chainIdRaw);
+  if (!Number.isFinite(chainId)) {
+    throw new OmaTrustError("INVALID_INPUT", "Invalid chain id in subjectDid", {
+      subjectDid: params.subjectDid
+    });
+  }
+  const code = await params.provider.getCode(subjectAddress);
+  const isContract = code !== "0x" && code !== "0x0";
+  if (!isContract) {
+    if (getAddress(subjectAddress) === getAddress(connectedWalletAddress)) {
+      return {
+        valid: true,
+        method: "wallet",
+        details: "Verified direct wallet ownership from matching did:pkh subject and connected wallet",
+        subjectDid,
+        connectedWalletDid
+      };
+    }
+    return {
+      valid: false,
+      reason: "EOA did:pkh subject does not match connected wallet",
+      details: "For direct wallet did:pkh subjects, connectedWalletDid must match the subject DID.",
+      subjectDid,
+      connectedWalletDid
+    };
+  }
+  const controllingWalletDid = await discoverControllingWalletDid(params.provider, subjectAddress, chainId);
+  if (params.txHash) {
+    if (!controllingWalletDid) {
+      return {
+        valid: false,
+        reason: "Could not discover controlling wallet",
+        details: "Contract does not expose owner/admin/getOwner or a readable EIP-1967 admin slot for transfer verification.",
+        subjectDid,
+        connectedWalletDid
+      };
+    }
+    const tx = await params.provider.getTransaction(params.txHash);
+    if (!tx) {
+      return {
+        valid: false,
+        reason: "Transaction not found",
+        details: `Transaction ${params.txHash} was not found on chain ${chainId}.`,
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid
+      };
+    }
+    const receipt = await params.provider.getTransactionReceipt(params.txHash);
+    if (!receipt) {
+      return {
+        valid: false,
+        reason: "Transaction not confirmed",
+        details: "Transaction exists but is not yet confirmed.",
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid
+      };
+    }
+    const controllingWalletAddress = getAddressFromDidPkh(controllingWalletDid);
+    if (!tx.from || !controllingWalletAddress || getAddress(tx.from) !== getAddress(controllingWalletAddress)) {
+      return {
+        valid: false,
+        reason: "Wrong sender",
+        details: `Transfer must originate from controlling wallet ${controllingWalletDid}.`,
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid
+      };
+    }
+    if (!tx.to || getAddress(tx.to) !== getAddress(connectedWalletAddress)) {
+      return {
+        valid: false,
+        reason: "Wrong recipient",
+        details: `Transfer must be sent to connected wallet ${connectedWalletDid}.`,
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid
+      };
+    }
+    const expectedAmount = calculateTransferAmount(
+      subjectDid,
+      connectedWalletDid,
+      chainId,
+      "shared-control"
+    );
+    const actualValue = BigInt(tx.value ?? 0n);
+    if (actualValue !== expectedAmount) {
+      return {
+        valid: false,
+        reason: "Wrong amount",
+        details: `Transfer amount ${actualValue.toString()} does not match expected proof amount ${expectedAmount.toString()}.`,
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid
+      };
+    }
+    await params.provider.getBlockNumber();
+    await params.provider.getBlock(receipt.blockNumber);
+    return {
+      valid: true,
+      method: "transfer",
+      details: `Verified via transfer proof ${params.txHash}.`,
+      subjectDid,
+      connectedWalletDid,
+      controllingWalletDid
+    };
+  }
+  for (const pattern of OWNERSHIP_PATTERNS) {
+    const ownerAddress = await readOwnerFromContract(
+      params.provider,
+      subjectAddress,
+      pattern.signature,
+      pattern.method
+    );
+    if (ownerAddress && getAddress(ownerAddress) === getAddress(connectedWalletAddress)) {
+      return {
+        valid: true,
+        method: "contract",
+        details: `Verified via ${pattern.method}() ownership check.`,
+        subjectDid,
+        connectedWalletDid,
+        controllingWalletDid: controllingWalletDid ?? void 0
+      };
+    }
+  }
+  try {
+    const adminValue = await params.provider.getStorage(subjectAddress, EIP1967_ADMIN_SLOT);
+    if (adminValue && adminValue !== "0x" && adminValue !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+      const adminAddress = getAddress(`0x${adminValue.slice(-40)}`);
+      if (adminAddress === getAddress(connectedWalletAddress)) {
+        return {
+          valid: true,
+          method: "contract",
+          details: "Verified via EIP-1967 admin slot.",
+          subjectDid,
+          connectedWalletDid,
+          controllingWalletDid: controllingWalletDid ?? buildEvmDidPkh(chainId, adminAddress)
+        };
+      }
+    }
+  } catch {
+  }
+  if (getAddress(subjectAddress) === getAddress(connectedWalletAddress) && controllingWalletDid) {
+    return {
+      valid: true,
+      method: "minting-wallet",
+      details: `Verified because connected wallet matches the contract DID address. Controlling wallet is ${controllingWalletDid}.`,
+      subjectDid,
+      connectedWalletDid,
+      controllingWalletDid
+    };
+  }
+  return {
+    valid: false,
+    reason: "Contract ownership verification failed",
+    details: controllingWalletDid ? `Connected wallet ${connectedWalletDid} does not match the controlling wallet ${controllingWalletDid} or the subject contract address ${subjectDid}.` : `Could not match connected wallet ${connectedWalletDid} to contract ownership for ${subjectDid}.`,
+    subjectDid,
+    connectedWalletDid,
+    controllingWalletDid: controllingWalletDid ?? void 0
+  };
+}
+async function verifySubjectOwnership(params) {
+  const subjectDid = normalizeSubjectDid(params.subjectDid);
+  const method = extractDidMethod(subjectDid);
+  if (method === "web") {
+    return verifyDidWebOwnership(params);
+  }
+  if (method === "pkh") {
+    const didPkhParams = params;
+    if (!didPkhParams.provider) {
+      throw new OmaTrustError(
+        "INVALID_INPUT",
+        "provider is required for did:pkh ownership verification",
+        { subjectDid }
+      );
+    }
+    return verifyDidPkhOwnership(didPkhParams);
+  }
+  throw new OmaTrustError("INVALID_INPUT", "Unsupported DID type for ownership verification", {
+    subjectDid
+  });
+}
+
+export { buildDelegatedAttestationTypedData, buildDelegatedTypedDataFromEncoded, buildDnsTxtRecord, buildEip712Domain, calculateAverageUserReviewRating, calculateTransferAmount, calculateTransferAmountFromAddresses, callControllerWitness, constructSeed, createEvidencePointerProof, createPopEip712Proof, createPopJwsProof, createTxEncodedValueProof, createTxInteractionProof, createX402OfferProof, createX402ReceiptProof, decodeAttestationData, deduplicateReviews, encodeAttestationData, extractEvmAddressesFromDidDocument, extractExpirationTime, extractJwksFromDidDocument, fetchDidDocument, formatSchemaUid, formatTransferAmount, getAttestation, getAttestationsByAttester, getAttestationsForDid, getChainConstants, getExplorerAddressUrl, getExplorerTxUrl, getLatestAttestations, getMajorVersion, getOmaTrustProofEip712Types, getSchemaDetails, getSupportedChainIds, hashSeed, isChainSupported, listAttestations, normalizeSchema, parseDnsTxtRecord, prepareDelegatedAttestation, requestControllerWitness, revokeAttestation, schemaToString, splitSignature, submitAttestation, submitDelegatedAttestation, validateAttestationData, verifyAttestation, verifyDidDocumentControllerDid, verifyDidJsonControllerDid, verifyDidPkhOwnership, verifyDidWebOwnership, verifyDnsTxtControllerDid2 as verifyDnsTxtControllerDid, verifyEip712Signature, verifyProof, verifySchemaExists, verifySubjectOwnership };
+//# sourceMappingURL=index.browser.js.map
+//# sourceMappingURL=index.browser.js.map