@neus/sdk 1.0.1 → 1.0.3

package/cjs/index.cjs

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -33,6 +34,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var SDKError, ApiError, ValidationError, NetworkError, ConfigurationError, VerificationError, AuthenticationError;
 var init_errors = __esm({
   "errors.js"() {
+    "use strict";
     SDKError = class _SDKError extends Error {
       constructor(message, code = "SDK_ERROR", details = {}) {
         super(message);
@@ -166,6 +168,49 @@ var init_errors = __esm({
 });
 
 // utils.js
+function encodeBase58Bytes(input) {
+  let source;
+  if (input instanceof Uint8Array) {
+    source = input;
+  } else if (input instanceof ArrayBuffer) {
+    source = new Uint8Array(input);
+  } else if (ArrayBuffer.isView(input)) {
+    source = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  } else if (typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(input)) {
+    source = new Uint8Array(input);
+  } else {
+    throw new SDKError("Unsupported non-EVM signature byte format", "INVALID_SIGNATURE_FORMAT");
+  }
+  if (source.length === 0)
+    return "";
+  let zeroes = 0;
+  while (zeroes < source.length && source[zeroes] === 0) {
+    zeroes++;
+  }
+  const iFactor = Math.log(256) / Math.log(58);
+  const size = (source.length - zeroes) * iFactor + 1 >>> 0;
+  const b58 = new Uint8Array(size);
+  let length = 0;
+  for (let i = zeroes; i < source.length; i++) {
+    let carry = source[i];
+    let j = 0;
+    for (let k = size - 1; (carry !== 0 || j < length) && k >= 0; k--, j++) {
+      carry += 256 * b58[k];
+      b58[k] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    length = j;
+  }
+  let it = size - length;
+  while (it < size && b58[it] === 0) {
+    it++;
+  }
+  let out = BASE58_ALPHABET[0].repeat(zeroes);
+  for (; it < size; it++) {
+    out += BASE58_ALPHABET[b58[it]];
+  }
+  return out;
+}
 function deterministicStringify(obj) {
   if (obj === null || obj === void 0) {
     return JSON.stringify(obj);
@@ -197,7 +242,7 @@ function constructVerificationMessage({ walletAddress, signedTimestamp, data, ve
   }
   const chainContext = typeof chain === "string" && chain.length > 0 ? chain : chainId;
   if (!chainContext) {
-    throw new SDKError("chainId is required (or provide chain for preview mode)", "INVALID_CHAIN_CONTEXT");
+    throw new SDKError("chainId is required (or provide chain for universal mode)", "INVALID_CHAIN_CONTEXT");
   }
   if (chainContext === chainId && typeof chainId !== "number") {
     throw new SDKError("chainId must be a number when provided", "INVALID_CHAIN_ID");
@@ -224,6 +269,29 @@ function validateWalletAddress(address) {
   }
   return /^0x[a-fA-F0-9]{40}$/.test(address);
 }
+function validateUniversalAddress(address, chain) {
+  if (!address || typeof address !== "string")
+    return false;
+  const value = address.trim();
+  if (!value)
+    return false;
+  const chainRef = typeof chain === "string" ? chain.trim().toLowerCase() : "";
+  const namespace = chainRef.includes(":") ? chainRef.split(":")[0] : "";
+  if (validateWalletAddress(value))
+    return true;
+  if (namespace === "eip155")
+    return false;
+  if (namespace === "solana") {
+    return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
+  }
+  if (namespace === "bip122") {
+    return /^(bc1|tb1|bcrt1)[a-z0-9]{11,87}$/.test(value.toLowerCase()) || /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,62}$/.test(value);
+  }
+  if (namespace === "near") {
+    return /^[a-z0-9._-]{2,64}$/.test(value);
+  }
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]{1,127}$/.test(value);
+}
 function validateTimestamp(timestamp, maxAgeMs = 5 * 60 * 1e3) {
   if (!timestamp || typeof timestamp !== "number") {
     return false;
@@ -245,7 +313,7 @@ function createVerificationData(content, owner, reference = null) {
   };
   return {
     content,
-    owner: owner.toLowerCase(),
+    owner: validateWalletAddress(owner) ? owner.toLowerCase() : owner,
     reference: reference || {
       // Must be a valid backend enum value; 'content' is not supported.
       type: "other",
@@ -270,6 +338,261 @@ function deriveDid(address, chainIdOrChain) {
     return `did:pkh:eip155:${chainContext}:${address.toLowerCase()}`;
   }
 }
+async function resolveDID(params, options = {}) {
+  const endpointPath = options.endpoint || "/api/v1/profile/did/resolve";
+  const apiUrl = typeof options.apiUrl === "string" ? options.apiUrl.trim() : "";
+  const resolveEndpoint = (path) => {
+    if (!path || typeof path !== "string")
+      return null;
+    const trimmedPath = path.trim();
+    if (!trimmedPath)
+      return null;
+    if (/^https?:\/\//i.test(trimmedPath))
+      return trimmedPath;
+    if (trimmedPath.startsWith("/")) {
+      if (!apiUrl)
+        return trimmedPath;
+      try {
+        return new URL(trimmedPath, apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`).toString();
+      } catch {
+        return null;
+      }
+    }
+    const base = apiUrl || NEUS_CONSTANTS.API_BASE_URL;
+    if (!base || typeof base !== "string")
+      return null;
+    try {
+      return new URL(trimmedPath, base.endsWith("/") ? base : `${base}/`).toString();
+    } catch {
+      return null;
+    }
+  };
+  const endpoint = resolveEndpoint(endpointPath);
+  if (!endpoint) {
+    throw new SDKError("resolveDID requires a valid endpoint", "INVALID_ENDPOINT");
+  }
+  const payload = {
+    walletAddress: params?.walletAddress,
+    chainId: params?.chainId,
+    chain: params?.chain
+  };
+  const isRelative = endpoint.startsWith("/") || !/^https?:\/\//i.test(endpoint);
+  const credentialsMode = options.credentials !== void 0 ? options.credentials : isRelative ? "same-origin" : "omit";
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers || {}
+      },
+      body: JSON.stringify(payload),
+      credentials: credentialsMode
+    });
+    const json = await response.json().catch(() => null);
+    if (!response.ok) {
+      const msg = json?.error?.message || json?.error || json?.message || "DID resolution failed";
+      throw new SDKError(msg, "DID_RESOLVE_FAILED", json);
+    }
+    const did = json?.data?.did || json?.did;
+    if (!did || typeof did !== "string") {
+      throw new SDKError("DID resolution missing DID", "DID_RESOLVE_MISSING", json);
+    }
+    return { did, data: json?.data || null, raw: json };
+  } catch (error) {
+    if (error instanceof SDKError)
+      throw error;
+    throw new SDKError(`DID resolution failed: ${error?.message || error}`, "DID_RESOLVE_FAILED");
+  }
+}
+async function standardizeVerificationRequest(params, options = {}) {
+  const endpointPath = options.endpoint || "/api/v1/verification/standardize";
+  const apiUrl = typeof options.apiUrl === "string" ? options.apiUrl.trim() : "";
+  const resolveEndpoint = (path) => {
+    if (!path || typeof path !== "string")
+      return null;
+    const trimmedPath = path.trim();
+    if (!trimmedPath)
+      return null;
+    if (/^https?:\/\//i.test(trimmedPath))
+      return trimmedPath;
+    if (trimmedPath.startsWith("/")) {
+      if (!apiUrl)
+        return trimmedPath;
+      try {
+        return new URL(trimmedPath, apiUrl.endsWith("/") ? apiUrl : `${apiUrl}/`).toString();
+      } catch {
+        return null;
+      }
+    }
+    const base = apiUrl || NEUS_CONSTANTS.API_BASE_URL;
+    if (!base || typeof base !== "string")
+      return null;
+    try {
+      return new URL(trimmedPath, base.endsWith("/") ? base : `${base}/`).toString();
+    } catch {
+      return null;
+    }
+  };
+  const endpoint = resolveEndpoint(endpointPath);
+  if (!endpoint) {
+    throw new SDKError("standardizeVerificationRequest requires a valid endpoint", "INVALID_ENDPOINT");
+  }
+  const isRelative = endpoint.startsWith("/") || !/^https?:\/\//i.test(endpoint);
+  const credentialsMode = options.credentials !== void 0 ? options.credentials : isRelative ? "same-origin" : "omit";
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers || {}
+      },
+      body: JSON.stringify(params || {}),
+      credentials: credentialsMode
+    });
+    const json = await response.json().catch(() => null);
+    if (!response.ok) {
+      const msg = json?.error?.message || json?.error || json?.message || "Standardize request failed";
+      throw new SDKError(msg, "STANDARDIZE_FAILED", json);
+    }
+    return json?.data || json;
+  } catch (error) {
+    if (error instanceof SDKError)
+      throw error;
+    throw new SDKError(`Standardize request failed: ${error?.message || error}`, "STANDARDIZE_FAILED");
+  }
+}
+function resolveZkPassportConfig(overrides = {}) {
+  const defaults = {
+    provider: "zkpassport",
+    scope: "basic_kyc",
+    checkSanctions: true,
+    requireFaceMatch: true,
+    faceMatchMode: "strict"
+  };
+  return {
+    ...defaults,
+    ...overrides && typeof overrides === "object" ? overrides : {}
+  };
+}
+function toHexUtf8(value) {
+  const input = typeof value === "string" ? value : String(value || "");
+  const bytes = new TextEncoder().encode(input);
+  return `0x${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+async function signMessage({ provider, message, walletAddress, chain } = {}) {
+  const msg = typeof message === "string" ? message : String(message || "");
+  if (!msg) {
+    throw new SDKError("signMessage: message is required", "INVALID_ARGUMENT");
+  }
+  const resolvedProvider = provider || (typeof window !== "undefined" && window?.ethereum ? window.ethereum : null);
+  if (!resolvedProvider) {
+    throw new SDKError("signMessage: provider is required", "SIGNER_UNAVAILABLE");
+  }
+  const chainStr = typeof chain === "string" && chain.trim().length > 0 ? chain.trim() : "eip155";
+  const namespace = chainStr.includes(":") ? chainStr.split(":")[0] || "eip155" : "eip155";
+  const resolveAddress = async () => {
+    if (typeof walletAddress === "string" && walletAddress.trim().length > 0)
+      return walletAddress;
+    if (namespace === "solana") {
+      if (resolvedProvider?.publicKey && typeof resolvedProvider.publicKey.toBase58 === "function") {
+        const pk = resolvedProvider.publicKey.toBase58();
+        if (typeof pk === "string" && pk)
+          return pk;
+      }
+      if (typeof resolvedProvider.getAddress === "function") {
+        const addr = await resolvedProvider.getAddress().catch(() => null);
+        if (typeof addr === "string" && addr)
+          return addr;
+      }
+      if (typeof resolvedProvider.address === "string" && resolvedProvider.address)
+        return resolvedProvider.address;
+      return null;
+    }
+    if (typeof resolvedProvider.address === "string" && resolvedProvider.address)
+      return resolvedProvider.address;
+    if (typeof resolvedProvider.getAddress === "function")
+      return await resolvedProvider.getAddress();
+    if (typeof resolvedProvider.request === "function") {
+      let accounts = await resolvedProvider.request({ method: "eth_accounts" }).catch(() => []);
+      if (!Array.isArray(accounts) || accounts.length === 0) {
+        accounts = await resolvedProvider.request({ method: "eth_requestAccounts" }).catch(() => []);
+      }
+      if (Array.isArray(accounts) && accounts[0])
+        return accounts[0];
+    }
+    return null;
+  };
+  if (namespace !== "eip155") {
+    if (typeof resolvedProvider.signMessage === "function") {
+      const encoded = typeof msg === "string" ? new TextEncoder().encode(msg) : msg;
+      const result = await resolvedProvider.signMessage(encoded);
+      if (typeof result === "string" && result)
+        return result;
+      if (result instanceof Uint8Array)
+        return encodeBase58Bytes(result);
+      if (result instanceof ArrayBuffer)
+        return encodeBase58Bytes(new Uint8Array(result));
+      if (ArrayBuffer.isView(result))
+        return encodeBase58Bytes(result);
+      if (typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(result))
+        return encodeBase58Bytes(result);
+    }
+    throw new SDKError("Non-EVM signing requires provider.signMessage", "SIGNER_UNAVAILABLE");
+  }
+  const address = await resolveAddress();
+  if (typeof resolvedProvider.request === "function" && address) {
+    let firstPersonalSignError = null;
+    try {
+      const sig = await resolvedProvider.request({ method: "personal_sign", params: [msg, address] });
+      if (typeof sig === "string" && sig)
+        return sig;
+    } catch (error) {
+      firstPersonalSignError = error;
+    }
+    let secondPersonalSignError = null;
+    try {
+      const sig = await resolvedProvider.request({ method: "personal_sign", params: [address, msg] });
+      if (typeof sig === "string" && sig)
+        return sig;
+    } catch (error) {
+      secondPersonalSignError = error;
+      const signatureErrorMessage = String(
+        error?.message || error?.reason || firstPersonalSignError?.message || firstPersonalSignError?.reason || ""
+      ).toLowerCase();
+      const needsHex = /byte|bytes|invalid byte sequence|encoding|non-hex/i.test(signatureErrorMessage);
+      if (needsHex) {
+        try {
+          const hexMsg = toHexUtf8(msg);
+          const sig = await resolvedProvider.request({ method: "personal_sign", params: [hexMsg, address] });
+          if (typeof sig === "string" && sig)
+            return sig;
+        } catch {
+        }
+      }
+    }
+    try {
+      const sig = await resolvedProvider.request({ method: "eth_sign", params: [address, msg] });
+      if (typeof sig === "string" && sig)
+        return sig;
+    } catch {
+    }
+    if (secondPersonalSignError || firstPersonalSignError) {
+      const lastError = secondPersonalSignError || firstPersonalSignError;
+      const isUserRejection = [4001, "ACTION_REJECTED"].includes(lastError?.code);
+      if (isUserRejection) {
+        throw lastError;
+      }
+    }
+  }
+  if (typeof resolvedProvider.signMessage === "function") {
+    const result = await resolvedProvider.signMessage(msg);
+    if (typeof result === "string" && result)
+      return result;
+  }
+  throw new SDKError("Unable to sign message with provided wallet/provider", "SIGNER_UNAVAILABLE");
+}
 function isTerminalStatus(status) {
   if (!status || typeof status !== "string")
     return false;
@@ -461,7 +784,7 @@ function validateVerifierPayload(verifierId, data) {
         result.missing.push(key);
     });
     if (!("ownerAddress" in data)) {
-      result.warnings.push("ownerAddress omitted (most deployments default to the signed walletAddress)");
+      result.warnings.push("ownerAddress omitted (defaults to the signed walletAddress)");
     }
   } else if (id === "token-holding") {
     ["contractAddress", "minBalance", "chainId"].forEach((key) => {
@@ -469,13 +792,17 @@ function validateVerifierPayload(verifierId, data) {
         result.missing.push(key);
     });
     if (!("ownerAddress" in data)) {
-      result.warnings.push("ownerAddress omitted (most deployments default to the signed walletAddress)");
+      result.warnings.push("ownerAddress omitted (defaults to the signed walletAddress)");
     }
   } else if (id === "ownership-basic") {
-    ["content"].forEach((key) => {
-      if (!(key in data))
-        result.missing.push(key);
-    });
+    if (!("owner" in data))
+      result.missing.push("owner");
+    const hasContent = typeof data.content === "string" && data.content.length > 0;
+    const hasContentHash = typeof data.contentHash === "string" && data.contentHash.length > 0;
+    const hasRefId = typeof data.reference?.id === "string" && data.reference.id.length > 0;
+    if (!hasContent && !hasContentHash && !hasRefId) {
+      result.missing.push("content (or contentHash or reference.id)");
+    }
   }
   if (result.missing.length > 0) {
     result.valid = false;
@@ -602,10 +929,12 @@ function validateSignatureComponents({ walletAddress, signature, signedTimestamp
   }
   return result;
 }
-var StatusPoller, NEUS_CONSTANTS;
+var BASE58_ALPHABET, StatusPoller, NEUS_CONSTANTS;
 var init_utils = __esm({
   "utils.js"() {
+    "use strict";
     init_errors();
+    BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
     StatusPoller = class {
       constructor(client, qHash, options = {}) {
         this.client = client;
@@ -648,10 +977,24 @@ var init_utils = __esm({
               }
               setTimeout(pollAttempt, this.currentInterval);
             } catch (error) {
-              reject(new SDKError(
-                `Polling failed: ${error.message}`,
-                "POLLING_ERROR"
-              ));
+              if (error instanceof ValidationError) {
+                reject(error);
+                return;
+              }
+              if (error instanceof ApiError && error.statusCode === 429 || error?.isRetryable === true) {
+                if (this.options.exponentialBackoff) {
+                  const next = Math.min(this.currentInterval * 2, this.options.maxInterval);
+                  const jitter = next * (0.5 + Math.random() * 0.5);
+                  this.currentInterval = Math.max(250, Math.floor(jitter));
+                }
+                if (this.attempt >= this.options.maxAttempts) {
+                  reject(new SDKError("Verification polling timeout", "POLLING_TIMEOUT"));
+                  return;
+                }
+                setTimeout(pollAttempt, this.currentInterval);
+                return;
+              }
+              reject(new SDKError(`Polling failed: ${error.message}`, "POLLING_ERROR"));
             }
           };
           pollAttempt();
@@ -696,23 +1039,103 @@ __export(client_exports, {
   NeusClient: () => NeusClient,
   constructVerificationMessage: () => constructVerificationMessage
 });
-var validateVerifierData, NeusClient;
+var FALLBACK_PUBLIC_VERIFIERS, INTERACTIVE_VERIFIERS, EVM_ADDRESS_RE, validateVerifierData, NeusClient;
 var init_client = __esm({
   "client.js"() {
+    "use strict";
     init_errors();
     init_utils();
+    FALLBACK_PUBLIC_VERIFIERS = [
+      "ownership-basic",
+      "ownership-pseudonym",
+      "ownership-dns-txt",
+      "ownership-social",
+      "ownership-org-oauth",
+      "contract-ownership",
+      "nft-ownership",
+      "token-holding",
+      "wallet-link",
+      "wallet-risk",
+      "proof-of-human",
+      "agent-identity",
+      "agent-delegation",
+      "ai-content-moderation"
+    ];
+    INTERACTIVE_VERIFIERS = /* @__PURE__ */ new Set([
+      "ownership-social",
+      "ownership-org-oauth",
+      "proof-of-human"
+    ]);
+    EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
     validateVerifierData = (verifierId, data) => {
       if (!data || typeof data !== "object") {
         return { valid: false, error: "Data object is required" };
       }
-      const ownerField = verifierId === "nft-ownership" || verifierId === "token-holding" ? "ownerAddress" : "owner";
-      if (data[ownerField] && !validateWalletAddress(data[ownerField])) {
-        return { valid: false, error: `Invalid ${ownerField} address` };
-      }
       switch (verifierId) {
         case "ownership-basic":
-          if (!data.owner || !validateWalletAddress(data.owner)) {
-            return { valid: false, error: "owner (wallet address) is required" };
+          if (!data.owner || !validateUniversalAddress(data.owner, typeof data.chain === "string" ? data.chain : void 0)) {
+            return { valid: false, error: "owner (universal wallet address) is required" };
+          }
+          if (data.content !== void 0 && data.content !== null) {
+            if (typeof data.content !== "string") {
+              return { valid: false, error: "content must be a string when provided" };
+            }
+            if (data.content.length > 5e4) {
+              return { valid: false, error: "content exceeds 50KB inline limit" };
+            }
+          }
+          if (data.contentHash !== void 0 && data.contentHash !== null) {
+            if (typeof data.contentHash !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(data.contentHash)) {
+              return { valid: false, error: "contentHash must be a 32-byte hex string (0x + 64 hex chars) when provided" };
+            }
+          }
+          if (data.contentType !== void 0 && data.contentType !== null) {
+            if (typeof data.contentType !== "string" || data.contentType.length > 100) {
+              return { valid: false, error: "contentType must be a string (max 100 chars) when provided" };
+            }
+            const base = String(data.contentType).split(";")[0].trim().toLowerCase();
+            if (!base || base.includes(" ") || !base.includes("/")) {
+              return { valid: false, error: "contentType must be a valid MIME type when provided" };
+            }
+          }
+          if (data.provenance !== void 0 && data.provenance !== null) {
+            if (!data.provenance || typeof data.provenance !== "object" || Array.isArray(data.provenance)) {
+              return { valid: false, error: "provenance must be an object when provided" };
+            }
+            const dk = data.provenance.declaredKind;
+            if (dk !== void 0 && dk !== null) {
+              const allowed = ["human", "ai", "mixed", "unknown"];
+              if (typeof dk !== "string" || !allowed.includes(dk)) {
+                return { valid: false, error: `provenance.declaredKind must be one of: ${allowed.join(", ")}` };
+              }
+            }
+            const ai = data.provenance.aiContext;
+            if (ai !== void 0 && ai !== null) {
+              if (typeof ai !== "object" || Array.isArray(ai)) {
+                return { valid: false, error: "provenance.aiContext must be an object when provided" };
+              }
+              if (ai.generatorType !== void 0 && ai.generatorType !== null) {
+                const allowed = ["local", "saas", "agent"];
+                if (typeof ai.generatorType !== "string" || !allowed.includes(ai.generatorType)) {
+                  return { valid: false, error: `provenance.aiContext.generatorType must be one of: ${allowed.join(", ")}` };
+                }
+              }
+              if (ai.provider !== void 0 && ai.provider !== null) {
+                if (typeof ai.provider !== "string" || ai.provider.length > 64) {
+                  return { valid: false, error: "provenance.aiContext.provider must be a string (max 64 chars) when provided" };
+                }
+              }
+              if (ai.model !== void 0 && ai.model !== null) {
+                if (typeof ai.model !== "string" || ai.model.length > 128) {
+                  return { valid: false, error: "provenance.aiContext.model must be a string (max 128 chars) when provided" };
+                }
+              }
+              if (ai.runId !== void 0 && ai.runId !== null) {
+                if (typeof ai.runId !== "string" || ai.runId.length > 128) {
+                  return { valid: false, error: "provenance.aiContext.runId must be a string (max 128 chars) when provided" };
+                }
+              }
+            }
           }
           if (data.reference !== void 0) {
             if (!data.reference || typeof data.reference !== "object") {
@@ -777,17 +1200,20 @@ var init_client = __esm({
           }
           break;
         case "wallet-link":
-          if (!data.primaryWalletAddress || !validateWalletAddress(data.primaryWalletAddress)) {
+          if (!data.primaryWalletAddress || !validateUniversalAddress(data.primaryWalletAddress, data.chain)) {
             return { valid: false, error: "primaryWalletAddress is required" };
           }
-          if (!data.secondaryWalletAddress || !validateWalletAddress(data.secondaryWalletAddress)) {
+          if (!data.secondaryWalletAddress || !validateUniversalAddress(data.secondaryWalletAddress, data.chain)) {
             return { valid: false, error: "secondaryWalletAddress is required" };
           }
           if (!data.signature || typeof data.signature !== "string") {
             return { valid: false, error: "signature is required (signed by secondary wallet)" };
           }
-          if (typeof data.chainId !== "number") {
-            return { valid: false, error: "chainId is required" };
+          if (typeof data.chain !== "string" || !/^[a-z0-9]+:[^\s]+$/.test(data.chain)) {
+            return { valid: false, error: "chain is required (namespace:reference)" };
+          }
+          if (typeof data.signatureMethod !== "string" || !data.signatureMethod.trim()) {
+            return { valid: false, error: "signatureMethod is required" };
           }
           if (typeof data.signedTimestamp !== "number") {
             return { valid: false, error: "signedTimestamp is required" };
@@ -852,6 +1278,17 @@ var init_client = __esm({
             if (!validTypes.includes(contentType)) {
               return { valid: false, error: `contentType must be one of: ${validTypes.join(", ")}` };
             }
+            const isTextual = contentType.startsWith("text/") || contentType.includes("markdown");
+            if (isTextual) {
+              try {
+                const maxBytes = 50 * 1024;
+                const bytes = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(data.content).length : String(data.content).length;
+                if (bytes > maxBytes) {
+                  return { valid: false, error: `content exceeds ${maxBytes} bytes limit for ai-content-moderation verifier (text)` };
+                }
+              } catch {
+              }
+            }
           }
           if (data.content.length > 13653334) {
             return { valid: false, error: "content exceeds 10MB limit" };
@@ -871,7 +1308,7 @@ var init_client = __esm({
           }
           break;
         case "wallet-risk":
-          if (data.walletAddress && !validateWalletAddress(data.walletAddress)) {
+          if (data.walletAddress && !validateUniversalAddress(data.walletAddress, data.chain)) {
             return { valid: false, error: "Invalid walletAddress" };
           }
           break;
@@ -903,6 +1340,26 @@ var init_client = __esm({
         if (typeof this.config.apiKey === "string" && this.config.apiKey.trim().length > 0) {
           this.defaultHeaders["Authorization"] = `Bearer ${this.config.apiKey.trim()}`;
         }
+        if (typeof this.config.appId === "string" && this.config.appId.trim().length > 0) {
+          this.defaultHeaders["X-Neus-App"] = this.config.appId.trim();
+        }
+        if (typeof this.config.sponsorGrant === "string" && this.config.sponsorGrant.trim().length > 0) {
+          this.defaultHeaders["X-Sponsor-Grant"] = this.config.sponsorGrant.trim();
+        }
+        if (typeof this.config.paymentSignature === "string" && this.config.paymentSignature.trim().length > 0) {
+          this.defaultHeaders["PAYMENT-SIGNATURE"] = this.config.paymentSignature.trim();
+        }
+        if (this.config.extraHeaders && typeof this.config.extraHeaders === "object") {
+          for (const [k, v] of Object.entries(this.config.extraHeaders)) {
+            if (!k || v === void 0 || v === null)
+              continue;
+            const key = String(k).trim();
+            const value = String(v).trim();
+            if (!key || !value)
+              continue;
+            this.defaultHeaders[key] = value;
+          }
+        }
         try {
           if (typeof window !== "undefined" && window.location && window.location.origin) {
             this.defaultHeaders["X-Client-Origin"] = window.location.origin;
@@ -910,6 +1367,122 @@ var init_client = __esm({
         } catch {
         }
       }
+      _getHubChainId() {
+        const configured = Number(this.config?.hubChainId);
+        if (Number.isFinite(configured) && configured > 0)
+          return Math.floor(configured);
+        return NEUS_CONSTANTS.HUB_CHAIN_ID;
+      }
+      _normalizeIdentity(value) {
+        let raw = String(value || "").trim();
+        if (!raw)
+          return "";
+        const didMatch = raw.match(/^did:pkh:([^:]+):([^:]+):(.+)$/i);
+        if (didMatch && didMatch[3]) {
+          raw = String(didMatch[3]).trim();
+        }
+        return EVM_ADDRESS_RE.test(raw) ? raw.toLowerCase() : raw;
+      }
+      _inferChainForAddress(address, explicitChain) {
+        if (typeof explicitChain === "string" && explicitChain.includes(":"))
+          return explicitChain.trim();
+        const raw = String(address || "").trim();
+        const didMatch = raw.match(/^did:pkh:([^:]+):([^:]+):(.+)$/i);
+        if (didMatch && didMatch[1] && didMatch[2]) {
+          return `${didMatch[1]}:${didMatch[2]}`;
+        }
+        if (EVM_ADDRESS_RE.test(raw)) {
+          return `eip155:${this._getHubChainId()}`;
+        }
+        return "solana:mainnet";
+      }
+      async _resolveWalletSigner(wallet) {
+        if (!wallet) {
+          throw new ConfigurationError("No wallet provider available");
+        }
+        if (wallet.address) {
+          return { signerWalletAddress: wallet.address, provider: wallet };
+        }
+        if (wallet.publicKey && typeof wallet.publicKey.toBase58 === "function") {
+          return { signerWalletAddress: wallet.publicKey.toBase58(), provider: wallet };
+        }
+        if (typeof wallet.getAddress === "function") {
+          const signerWalletAddress = await wallet.getAddress().catch(() => null);
+          return { signerWalletAddress, provider: wallet };
+        }
+        if (wallet.selectedAddress || wallet.request) {
+          const provider = wallet;
+          if (wallet.selectedAddress) {
+            return { signerWalletAddress: wallet.selectedAddress, provider };
+          }
+          const accounts = await provider.request({ method: "eth_accounts" });
+          if (!accounts || accounts.length === 0) {
+            throw new ConfigurationError("No wallet accounts available");
+          }
+          return { signerWalletAddress: accounts[0], provider };
+        }
+        throw new ConfigurationError("Invalid wallet provider");
+      }
+      _getDefaultBrowserWallet() {
+        if (typeof window === "undefined")
+          return null;
+        return window.ethereum || window.solana || window.phantom && window.phantom.solana || null;
+      }
+      async _buildPrivateGateAuth({ address, wallet, chain, signatureMethod } = {}) {
+        const providerWallet = wallet || this._getDefaultBrowserWallet();
+        const { signerWalletAddress, provider } = await this._resolveWalletSigner(providerWallet);
+        if (!signerWalletAddress || typeof signerWalletAddress !== "string") {
+          throw new ConfigurationError("No wallet accounts available");
+        }
+        const normalizedSigner = this._normalizeIdentity(signerWalletAddress);
+        const normalizedAddress = this._normalizeIdentity(address);
+        if (!normalizedSigner || normalizedSigner !== normalizedAddress) {
+          throw new ValidationError("wallet must match address when includePrivate=true");
+        }
+        const signerIsEvm = EVM_ADDRESS_RE.test(normalizedSigner);
+        const resolvedChain = this._inferChainForAddress(normalizedSigner, chain);
+        const resolvedSignatureMethod = typeof signatureMethod === "string" && signatureMethod.trim() ? signatureMethod.trim() : signerIsEvm ? "eip191" : "ed25519";
+        const signedTimestamp = Date.now();
+        const message = constructVerificationMessage({
+          walletAddress: signerWalletAddress,
+          signedTimestamp,
+          data: { action: "gate_check_private_proofs", walletAddress: normalizedAddress },
+          verifierIds: ["ownership-basic"],
+          ...signerIsEvm ? { chainId: this._getHubChainId() } : { chain: resolvedChain }
+        });
+        let signature;
+        try {
+          signature = await signMessage({
+            provider,
+            message,
+            walletAddress: signerWalletAddress,
+            ...signerIsEvm ? {} : { chain: resolvedChain }
+          });
+        } catch (error) {
+          if (error.code === 4001) {
+            throw new ValidationError("User rejected signature request");
+          }
+          throw new ValidationError(`Failed to sign message: ${error.message}`);
+        }
+        return {
+          walletAddress: signerWalletAddress,
+          signature,
+          signedTimestamp,
+          ...signerIsEvm ? {} : { chain: resolvedChain, signatureMethod: resolvedSignatureMethod }
+        };
+      }
+      async createGatePrivateAuth(params = {}) {
+        const address = (params.address || "").toString();
+        if (!validateUniversalAddress(address, params.chain)) {
+          throw new ValidationError("Valid address is required");
+        }
+        return this._buildPrivateGateAuth({
+          address,
+          wallet: params.wallet,
+          chain: params.chain,
+          signatureMethod: params.signatureMethod
+        });
+      }
       // ============================================================================
       // CORE VERIFICATION METHODS
       // ============================================================================
@@ -931,7 +1504,7 @@ var init_client = __esm({
        * @param {string} [params.verifier] - Verifier ID (auto path)
        * @param {string} [params.content] - Content/description (auto path)
        * @param {Object} [params.wallet] - Optional injected wallet/provider (auto path)
-       * @returns {Promise<Object>} Verification result with qHash
+       * @returns {Promise<Object>} Verification result with proofId (qHash is a deprecated alias)
        * 
        * @example
        * const proof = await client.verify({
@@ -939,7 +1512,7 @@ var init_client = __esm({
        *   data: {
        *     content: "My content",
        *     owner: walletAddress, // or ownerAddress for nft-ownership/token-holding
-       *     reference: { type: 'content', id: 'my-unique-identifier' }
+       *     reference: { type: 'other', id: 'my-unique-identifier' }
        *   },
        *   walletAddress: '0x...',
        *   signature: '0x...',
@@ -956,7 +1529,7 @@ var init_client = __esm({
        * @param {Object} [params.data] - Structured verification data
        * @param {Object} [params.wallet] - Wallet provider
        * @param {Object} [params.options] - Additional options
-       * @returns {Promise<Object>} Verification result with qHash
+       * @returns {Promise<Object>} Verification result with proofId (qHash is a deprecated alias)
        *
        * @example
        * // Simple ownership proof
@@ -972,25 +1545,23 @@ var init_client = __esm({
           if (verifier === "ownership-basic" && !data2 && (!content || typeof content !== "string")) {
             throw new ValidationError("content is required and must be a string (or use data param with owner + reference)");
           }
-          const validVerifiers = [
-            "ownership-basic",
-            "ownership-pseudonym",
-            // Pseudonymous identity (public)
-            "nft-ownership",
-            "token-holding",
-            "ownership-dns-txt",
-            "wallet-link",
-            "contract-ownership",
-            "wallet-risk",
-            // Wallet risk assessment (public)
-            // AI & Agent verifiers (ERC-8004 aligned)
-            "agent-identity",
-            "agent-delegation",
-            "ai-content-moderation"
-          ];
+          let validVerifiers = FALLBACK_PUBLIC_VERIFIERS;
+          try {
+            const discovered = await this.getVerifiers();
+            if (Array.isArray(discovered) && discovered.length > 0) {
+              validVerifiers = discovered;
+            }
+          } catch {
+          }
           if (!validVerifiers.includes(verifier)) {
             throw new ValidationError(`Invalid verifier '${verifier}'. Must be one of: ${validVerifiers.join(", ")}.`);
           }
+          if (INTERACTIVE_VERIFIERS.has(verifier)) {
+            const hostedCheckoutUrl = options2?.hostedCheckoutUrl || "https://neus.network/verify";
+            throw new ValidationError(
+              `${verifier} requires hosted interactive checkout. Use VerifyGate or redirect to ${hostedCheckoutUrl}.`
+            );
+          }
           const requiresDataParam = [
             "ownership-dns-txt",
             "wallet-link",
@@ -1008,8 +1579,12 @@ var init_client = __esm({
           }
           let walletAddress2, provider;
           if (wallet) {
-            walletAddress2 = wallet.address || wallet.selectedAddress;
+            walletAddress2 = wallet.address || wallet.selectedAddress || wallet.walletAddress || (typeof wallet.getAddress === "function" ? await wallet.getAddress() : null);
             provider = wallet.provider || wallet;
+            if (!walletAddress2 && provider && typeof provider.request === "function") {
+              const accounts = await provider.request({ method: "eth_accounts" });
+              walletAddress2 = Array.isArray(accounts) ? accounts[0] : null;
+            }
           } else {
             if (typeof window === "undefined" || !window.ethereum) {
               throw new ConfigurationError("No Web3 wallet detected. Please install MetaMask or provide wallet parameter.");
@@ -1027,6 +1602,7 @@ var init_client = __esm({
                 reference: data2.reference,
                 ...data2.content && { content: data2.content },
                 ...data2.contentHash && { contentHash: data2.contentHash },
+                ...data2.contentType && { contentType: data2.contentType },
                 ...data2.provenance && { provenance: data2.provenance }
               };
             } else {
@@ -1084,14 +1660,18 @@ var init_client = __esm({
             if (!data2?.signature) {
               throw new ValidationError("wallet-link requires signature in data parameter (signed by secondary wallet)");
             }
-            if (typeof data2?.chainId !== "number") {
-              throw new ValidationError("wallet-link requires chainId (number) in data parameter");
+            if (typeof data2?.chain !== "string" || !/^[a-z0-9]+:[^\s]+$/.test(data2.chain)) {
+              throw new ValidationError("wallet-link requires chain (namespace:reference) in data parameter");
+            }
+            if (typeof data2?.signatureMethod !== "string" || !data2.signatureMethod.trim()) {
+              throw new ValidationError("wallet-link requires signatureMethod in data parameter");
             }
             verificationData = {
               primaryWalletAddress: walletAddress2,
               secondaryWalletAddress: data2.secondaryWalletAddress,
               signature: data2.signature,
-              chainId: data2.chainId,
+              chain: data2.chain,
+              signatureMethod: data2.signatureMethod,
               signedTimestamp: data2?.signedTimestamp || Date.now()
             };
           } else if (verifier === "contract-ownership") {
@@ -1180,12 +1760,12 @@ var init_client = __esm({
             signedTimestamp: signedTimestamp2,
             data: verificationData,
             verifierIds: verifierIds2,
-            chainId: NEUS_CONSTANTS.HUB_CHAIN_ID
+            chainId: this._getHubChainId()
             // Protocol-managed chain
           });
           let signature2;
           try {
-            const toHexUtf8 = (s) => {
+            const toHexUtf82 = (s) => {
               try {
                 const enc = new TextEncoder();
                 const bytes = enc.encode(s);
@@ -1221,7 +1801,7 @@ var init_client = __esm({
             })();
             if (isFarcasterWallet) {
               try {
-                const hexMsg = toHexUtf8(message);
+                const hexMsg = toHexUtf82(message);
                 signature2 = await provider.request({ method: "personal_sign", params: [hexMsg, walletAddress2] });
               } catch (e) {
               }
@@ -1270,7 +1850,7 @@ ${bytes.length}`;
                   }
                 } else if (needsHex) {
                   this._log("Retrying personal_sign with hex-encoded message");
-                  const hexMsg = toHexUtf8(message);
+                  const hexMsg = toHexUtf82(message);
                   signature2 = await provider.request({ method: "personal_sign", params: [hexMsg, walletAddress2] });
                 } else {
                   throw e;
@@ -1368,18 +1948,18 @@ ${bytes.length}`;
       /**
        * Get verification status
        *
-       * @param {string} qHash - Verification ID (qHash or proofId)
+       * @param {string} proofId - Proof ID (standard). `qHash` is a deprecated alias (same value).
        * @returns {Promise<Object>} Verification status and data
        *
        * @example
        * const result = await client.getStatus('0x...');
        * console.log('Status:', result.status);
        */
-      async getStatus(qHash) {
-        if (!qHash || typeof qHash !== "string") {
-          throw new ValidationError("qHash is required");
+      async getStatus(proofId) {
+        if (!proofId || typeof proofId !== "string") {
+          throw new ValidationError("proofId is required");
         }
-        const response = await this._makeRequest("GET", `/api/v1/verification/status/${qHash}`);
+        const response = await this._makeRequest("GET", `/api/v1/verification/status/${proofId}`);
         if (!response.success) {
           throw new ApiError(`Failed to get status: ${response.error?.message || "Unknown error"}`, response.error);
         }
@@ -1388,70 +1968,72 @@ ${bytes.length}`;
       /**
        * Get private proof status with wallet signature
        *
-       * @param {string} qHash - Verification ID
+       * @param {string} proofId - Proof ID (standard). `qHash` is a deprecated alias (same value).
        * @param {Object} wallet - Wallet provider (window.ethereum or ethers Wallet)
        * @returns {Promise<Object>} Private verification status and data
        *
        * @example
        * // Access private proof
-       * const privateData = await client.getPrivateStatus(qHash, window.ethereum);
+       * const privateData = await client.getPrivateStatus(proofId, window.ethereum);
        */
-      async getPrivateStatus(qHash, wallet = null) {
-        if (!qHash || typeof qHash !== "string") {
-          throw new ValidationError("qHash is required");
+      async getPrivateStatus(proofId, wallet = null) {
+        if (!proofId || typeof proofId !== "string") {
+          throw new ValidationError("proofId is required");
         }
-        if (!wallet) {
-          if (typeof window === "undefined" || !window.ethereum) {
-            throw new ConfigurationError("No wallet provider available");
+        const isPreSignedAuth = wallet && typeof wallet === "object" && typeof wallet.walletAddress === "string" && typeof wallet.signature === "string" && typeof wallet.signedTimestamp === "number";
+        if (isPreSignedAuth) {
+          const auth = wallet;
+          const headers = {
+            "x-wallet-address": String(auth.walletAddress),
+            "x-signature": String(auth.signature),
+            "x-signed-timestamp": String(auth.signedTimestamp),
+            ...typeof auth.chain === "string" && auth.chain.trim() ? { "x-chain": auth.chain.trim() } : {},
+            ...typeof auth.signatureMethod === "string" && auth.signatureMethod.trim() ? { "x-signature-method": auth.signatureMethod.trim() } : {}
+          };
+          const response2 = await this._makeRequest("GET", `/api/v1/verification/status/${proofId}`, null, headers);
+          if (!response2.success) {
+            throw new ApiError(
+              `Failed to access private proof: ${response2.error?.message || "Unauthorized"}`,
+              response2.error
+            );
           }
-          wallet = window.ethereum;
+          return this._formatResponse(response2);
         }
-        let walletAddress, provider;
-        if (wallet.address) {
-          walletAddress = wallet.address;
-          provider = wallet;
-        } else if (wallet.selectedAddress || wallet.request) {
-          provider = wallet;
-          if (wallet.selectedAddress) {
-            walletAddress = wallet.selectedAddress;
-          } else {
-            const accounts = await provider.request({ method: "eth_accounts" });
-            if (!accounts || accounts.length === 0) {
-              throw new ConfigurationError("No wallet accounts available");
-            }
-            walletAddress = accounts[0];
-          }
-        } else {
-          throw new ConfigurationError("Invalid wallet provider");
+        const providerWallet = wallet || this._getDefaultBrowserWallet();
+        const { signerWalletAddress: walletAddress, provider } = await this._resolveWalletSigner(providerWallet);
+        if (!walletAddress || typeof walletAddress !== "string") {
+          throw new ConfigurationError("No wallet accounts available");
         }
+        const signerIsEvm = EVM_ADDRESS_RE.test(this._normalizeIdentity(walletAddress));
+        const chain = this._inferChainForAddress(walletAddress);
+        const signatureMethod = signerIsEvm ? "eip191" : "ed25519";
         const signedTimestamp = Date.now();
         const message = constructVerificationMessage({
           walletAddress,
           signedTimestamp,
-          data: { action: "access_private_proof", qHash },
+          data: { action: "access_private_proof", qHash: proofId },
           verifierIds: ["ownership-basic"],
-          chainId: NEUS_CONSTANTS.HUB_CHAIN_ID
+          ...signerIsEvm ? { chainId: this._getHubChainId() } : { chain }
         });
         let signature;
         try {
-          if (provider.signMessage) {
-            signature = await provider.signMessage(message);
-          } else {
-            signature = await provider.request({
-              method: "personal_sign",
-              params: [message, walletAddress]
-            });
-          }
+          signature = await signMessage({
+            provider,
+            message,
+            walletAddress,
+            ...signerIsEvm ? {} : { chain }
+          });
         } catch (error) {
           if (error.code === 4001) {
             throw new ValidationError("User rejected signature request");
           }
           throw new ValidationError(`Failed to sign message: ${error.message}`);
         }
-        const response = await this._makeRequest("GET", `/api/v1/verification/status/${qHash}`, null, {
+        const response = await this._makeRequest("GET", `/api/v1/verification/status/${proofId}`, null, {
           "x-wallet-address": walletAddress,
           "x-signature": signature,
-          "x-signed-timestamp": signedTimestamp.toString()
+          "x-signed-timestamp": signedTimestamp.toString(),
+          ...signerIsEvm ? {} : { "x-chain": chain, "x-signature-method": signatureMethod }
         });
         if (!response.success) {
           throw new ApiError(
@@ -1492,7 +2074,7 @@ ${bytes.length}`;
        * Polls the verification status until it reaches a terminal state (completed or failed).
        * Useful for providing real-time feedback to users during verification.
        * 
-       * @param {string} qHash - Verification ID to poll
+       * @param {string} proofId - Proof ID to poll (standard). `qHash` is a deprecated alias (same value).
        * @param {Object} [options] - Polling options
        * @param {number} [options.interval=5000] - Polling interval in ms
        * @param {number} [options.timeout=120000] - Total timeout in ms
@@ -1500,7 +2082,7 @@ ${bytes.length}`;
        * @returns {Promise<Object>} Final verification status
        * 
        * @example
-       * const finalStatus = await client.pollProofStatus(qHash, {
+       * const finalStatus = await client.pollProofStatus(proofId, {
        *   interval: 3000,
        *   timeout: 60000,
        *   onProgress: (status) => {
@@ -1511,19 +2093,21 @@ ${bytes.length}`;
        *   }
        * });
        */
-      async pollProofStatus(qHash, options = {}) {
+      async pollProofStatus(proofId, options = {}) {
         const {
           interval = 5e3,
           timeout = 12e4,
           onProgress
         } = options;
-        if (!qHash || typeof qHash !== "string") {
-          throw new ValidationError("qHash is required");
+        if (!proofId || typeof proofId !== "string") {
+          throw new ValidationError("proofId is required");
         }
         const startTime = Date.now();
+        let consecutiveRateLimits = 0;
         while (Date.now() - startTime < timeout) {
           try {
-            const status = await this.getStatus(qHash);
+            const status = await this.getStatus(proofId);
+            consecutiveRateLimits = 0;
             if (onProgress && typeof onProgress === "function") {
               onProgress(status.data || status);
             }
@@ -1538,7 +2122,17 @@ ${bytes.length}`;
             if (error instanceof ValidationError) {
               throw error;
             }
-            await new Promise((resolve) => setTimeout(resolve, interval));
+            let nextDelay = interval;
+            if (error instanceof ApiError && Number(error.statusCode) === 429) {
+              consecutiveRateLimits += 1;
+              const exp = Math.min(6, consecutiveRateLimits);
+              const base = Math.max(500, Number(interval) || 0);
+              const max = 3e4;
+              const backoff = Math.min(max, base * Math.pow(2, exp));
+              const jitter = Math.floor(backoff * (0.5 + Math.random() * 0.5));
+              nextDelay = jitter;
+            }
+            await new Promise((resolve) => setTimeout(resolve, nextDelay));
           }
         }
         throw new NetworkError(`Polling timeout after ${timeout}ms`, "POLLING_TIMEOUT");
@@ -1560,70 +2154,51 @@ ${bytes.length}`;
         }
       }
       /** Revoke your own proof (owner-signed) */
-      async revokeOwnProof(qHash, wallet) {
-        if (!qHash || typeof qHash !== "string") {
-          throw new ValidationError("qHash is required");
+      async revokeOwnProof(proofId, wallet) {
+        if (!proofId || typeof proofId !== "string") {
+          throw new ValidationError("proofId is required");
+        }
+        const providerWallet = wallet || this._getDefaultBrowserWallet();
+        const { signerWalletAddress: address, provider } = await this._resolveWalletSigner(providerWallet);
+        if (!address || typeof address !== "string") {
+          throw new ConfigurationError("No wallet accounts available");
         }
-        const address = wallet?.address || await this._getWalletAddress();
+        const signerIsEvm = EVM_ADDRESS_RE.test(this._normalizeIdentity(address));
+        const chain = this._inferChainForAddress(address);
+        const signatureMethod = signerIsEvm ? "eip191" : "ed25519";
         const signedTimestamp = Date.now();
-        const hubChainId = NEUS_CONSTANTS.HUB_CHAIN_ID;
         const message = constructVerificationMessage({
           walletAddress: address,
           signedTimestamp,
-          data: { action: "revoke_proof", qHash },
+          // Keep wire payload key `qHash` for backwards compatibility.
+          data: { action: "revoke_proof", qHash: proofId },
           verifierIds: ["ownership-basic"],
-          chainId: hubChainId
+          ...signerIsEvm ? { chainId: this._getHubChainId() } : { chain }
         });
         let signature;
         try {
-          const toHexUtf8 = (s) => {
-            const enc = new TextEncoder();
-            const bytes = enc.encode(s);
-            let hex = "0x";
-            for (let i = 0; i < bytes.length; i++)
-              hex += bytes[i].toString(16).padStart(2, "0");
-            return hex;
-          };
-          const isFarcasterWallet = (() => {
-            if (typeof window === "undefined")
-              return false;
-            try {
-              const w = window;
-              const fc = w.farcaster;
-              if (!fc || !fc.context)
-                return false;
-              const fcProvider = fc.provider || fc.walletProvider || fc.context && fc.context.walletProvider;
-              if (fcProvider === w.ethereum)
-                return true;
-              if (w.mini && w.mini.wallet === w.ethereum && fc && fc.context)
-                return true;
-              if (w.ethereum && fc && fc.context)
-                return true;
-            } catch {
-            }
-            return false;
-          })();
-          if (isFarcasterWallet) {
-            try {
-              const hexMsg = toHexUtf8(message);
-              signature = await window.ethereum.request({ method: "personal_sign", params: [hexMsg, address] });
-            } catch {
-            }
-          }
-          if (!signature) {
-            signature = await window.ethereum.request({ method: "personal_sign", params: [message, address] });
-          }
+          signature = await signMessage({
+            provider,
+            message,
+            walletAddress: address,
+            ...signerIsEvm ? {} : { chain }
+          });
         } catch (error) {
           if (error.code === 4001) {
             throw new ValidationError("User rejected revocation signature");
           }
           throw new ValidationError(`Failed to sign revocation: ${error.message}`);
         }
-        const res = await fetch(`${this.config.apiUrl}/api/v1/proofs/${qHash}/revoke-self`, {
+        const res = await fetch(`${this.config.apiUrl}/api/v1/proofs/${proofId}/revoke-self`, {
           method: "POST",
           // SECURITY: Do not put proof signatures into Authorization headers.
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ walletAddress: address, signature, signedTimestamp })
+          body: JSON.stringify({
+            walletAddress: address,
+            signature,
+            signedTimestamp,
+            ...signerIsEvm ? {} : { chain, signatureMethod }
+          })
         });
         const json = await res.json();
         if (!json.success) {
@@ -1632,12 +2207,12 @@ ${bytes.length}`;
         return true;
       }
       // ============================================================================
-      // GATE & LOOKUP METHODS
+      // PROOFS & GATING METHODS
       // ============================================================================
       /**
        * GET PROOFS BY WALLET - Fetch proofs for a wallet address
        * 
-       * @param {string} walletAddress - Wallet address (0x...) or DID (did:pkh:...)
+       * @param {string} walletAddress - Wallet identity (EVM/Solana/DID)
        * @param {Object} [options] - Filter options
        * @param {number} [options.limit] - Max results (default: 50; higher limits require owner access)
        * @param {number} [options.offset] - Pagination offset (default: 0)
@@ -1682,7 +2257,7 @@ ${bytes.length}`;
        *
        * Signs an owner-access intent and requests private proofs via signature headers.
        *
-       * @param {string} walletAddress - Wallet address (0x...) or DID (did:pkh:...)
+       * @param {string} walletAddress - Wallet identity (EVM/Solana/DID)
        * @param {Object} [options]
        * @param {number} [options.limit] - Max results (server enforces caps)
        * @param {number} [options.offset] - Pagination offset
@@ -1694,48 +2269,41 @@ ${bytes.length}`;
         }
         const id = walletAddress.trim();
         const pathId = /^0x[a-fA-F0-9]{40}$/i.test(id) ? id.toLowerCase() : id;
+        const requestedIdentity = this._normalizeIdentity(id);
         if (!wallet) {
-          if (typeof window === "undefined" || !window.ethereum) {
+          const defaultWallet = this._getDefaultBrowserWallet();
+          if (!defaultWallet) {
             throw new ConfigurationError("No wallet provider available");
           }
-          wallet = window.ethereum;
+          wallet = defaultWallet;
         }
-        let signerWalletAddress, provider;
-        if (wallet.address) {
-          signerWalletAddress = wallet.address;
-          provider = wallet;
-        } else if (wallet.selectedAddress || wallet.request) {
-          provider = wallet;
-          if (wallet.selectedAddress) {
-            signerWalletAddress = wallet.selectedAddress;
-          } else {
-            const accounts = await provider.request({ method: "eth_accounts" });
-            if (!accounts || accounts.length === 0) {
-              throw new ConfigurationError("No wallet accounts available");
-            }
-            signerWalletAddress = accounts[0];
-          }
-        } else {
-          throw new ConfigurationError("Invalid wallet provider");
+        const { signerWalletAddress, provider } = await this._resolveWalletSigner(wallet);
+        if (!signerWalletAddress || typeof signerWalletAddress !== "string") {
+          throw new ConfigurationError("No wallet accounts available");
         }
+        const normalizedSigner = this._normalizeIdentity(signerWalletAddress);
+        if (!normalizedSigner || normalizedSigner !== requestedIdentity) {
+          throw new ValidationError("wallet must match walletAddress for private proof access");
+        }
+        const signerIsEvm = EVM_ADDRESS_RE.test(normalizedSigner);
+        const chain = this._inferChainForAddress(normalizedSigner, options?.chain);
+        const signatureMethod = typeof options?.signatureMethod === "string" && options.signatureMethod.trim() ? options.signatureMethod.trim() : signerIsEvm ? "eip191" : "ed25519";
         const signedTimestamp = Date.now();
         const message = constructVerificationMessage({
           walletAddress: signerWalletAddress,
           signedTimestamp,
-          data: { action: "access_private_proofs_by_wallet", walletAddress: signerWalletAddress.toLowerCase() },
+          data: { action: "access_private_proofs_by_wallet", walletAddress: normalizedSigner },
           verifierIds: ["ownership-basic"],
-          chainId: NEUS_CONSTANTS.HUB_CHAIN_ID
+          ...signerIsEvm ? { chainId: this._getHubChainId() } : { chain }
         });
         let signature;
         try {
-          if (provider.signMessage) {
-            signature = await provider.signMessage(message);
-          } else {
-            signature = await provider.request({
-              method: "personal_sign",
-              params: [message, signerWalletAddress]
-            });
-          }
+          signature = await signMessage({
+            provider,
+            message,
+            walletAddress: signerWalletAddress,
+            ...signerIsEvm ? {} : { chain }
+          });
         } catch (error) {
           if (error.code === 4001) {
             throw new ValidationError("User rejected signature request");
@@ -1751,7 +2319,8 @@ ${bytes.length}`;
         const response = await this._makeRequest("GET", `/api/v1/proofs/byWallet/${encodeURIComponent(pathId)}${query}`, null, {
           "x-wallet-address": signerWalletAddress,
           "x-signature": signature,
-          "x-signed-timestamp": signedTimestamp.toString()
+          "x-signed-timestamp": signedTimestamp.toString(),
+          ...signerIsEvm ? {} : { "x-chain": chain, "x-signature-method": signatureMethod }
         });
         if (!response.success) {
           throw new ApiError(`Failed to get proofs: ${response.error?.message || "Unauthorized"}`, response.error);
@@ -1765,68 +2334,34 @@ ${bytes.length}`;
           nextOffset: response.data?.nextOffset ?? null
         };
       }
-      /**
-       * LOOKUP MODE (API) - Non-persistent server-to-server checks
-       *
-       * Runs `external_lookup` verifiers without minting/storing a proof.
-       * Requires an enterprise API key (server-side only).
-       *
-       * @param {Object} params
-       * @param {string} params.apiKey - Enterprise API key (sk_live_... or sk_test_...)
-       * @param {Array<string>} params.verifierIds - Verifiers to run (external_lookup only)
-       * @param {string} params.targetWalletAddress - Wallet to evaluate
-       * @param {Object} [params.data] - Verifier input data (e.g., contractAddress/tokenId/chainId)
-       * @returns {Promise<Object>} API response ({ success, data })
-       */
-      async lookup(params = {}) {
-        const apiKey = (params.apiKey || "").toString().trim();
-        if (!apiKey || !(apiKey.startsWith("sk_live_") || apiKey.startsWith("sk_test_"))) {
-          throw new ValidationError("lookup requires apiKey (sk_live_* or sk_test_*)");
-        }
-        const verifierIds = Array.isArray(params.verifierIds) ? params.verifierIds.map((v) => String(v).trim()).filter(Boolean) : [];
-        if (verifierIds.length === 0) {
-          throw new ValidationError("lookup requires verifierIds (non-empty array)");
-        }
-        const targetWalletAddress = (params.targetWalletAddress || "").toString().trim();
-        if (!targetWalletAddress || !/^0x[a-fA-F0-9]{40}$/i.test(targetWalletAddress)) {
-          throw new ValidationError("lookup requires a valid targetWalletAddress (0x...)");
-        }
-        const body = {
-          verifierIds,
-          targetWalletAddress,
-          data: params.data && typeof params.data === "object" ? params.data : {}
-        };
-        const response = await this._makeRequest("POST", "/api/v1/verification/lookup", body, {
-          Authorization: `Bearer ${apiKey}`
-        });
-        if (!response.success) {
-          throw new ApiError(`Lookup failed: ${response.error?.message || "Unknown error"}`, response.error);
-        }
-        return response;
-      }
       /**
        * GATE CHECK (API) - Minimal eligibility check
        *
-       * Calls the public gate endpoint and returns a **minimal** yes/no response
-       * against **public + discoverable** proofs only.
+       * Calls the gate endpoint and returns a **minimal** yes/no response.
+       * By default this checks **public + discoverable** proofs only.
+       *
+       * When `includePrivate=true`, this can perform owner-signed private checks
+       * (no full proof payloads returned) by providing a wallet/provider.
        *
-       * Prefer this over `checkGate()` for server-side integrations that want the
+       * Prefer this over `checkGate()` for integrations that want the
        * smallest, most stable surface area (and do NOT need full proof payloads).
        *
        * @param {Object} params - Gate check query params
-       * @param {string} params.address - Wallet address to check (0x...)
+       * @param {string} params.address - Wallet identity to check (EVM/Solana/DID)
        * @param {Array<string>|string} [params.verifierIds] - Verifier IDs to match (array or comma-separated)
        * @param {boolean} [params.requireAll] - Require all verifierIds on a single proof
        * @param {number} [params.minCount] - Minimum number of matching proofs
        * @param {number} [params.sinceDays] - Optional time window in days
        * @param {number} [params.since] - Optional unix timestamp in ms (lower bound)
        * @param {number} [params.limit] - Max rows to scan (server may clamp)
-       * @param {string} [params.select] - Comma-separated projections (handle,provider,profileUrl,traits.<key>)
+       * @param {boolean} [params.includePrivate] - Include private proofs for owner-authenticated requests
+       * @param {boolean} [params.includeQHashes] - Include matched qHashes in response (minimal IDs only)
+       * @param {Object} [params.wallet] - Optional wallet/provider used to sign includePrivate owner checks
        * @returns {Promise<Object>} API response ({ success, data })
        */
       async gateCheck(params = {}) {
         const address = (params.address || "").toString();
-        if (!address || !/^0x[a-fA-F0-9]{40}$/i.test(address)) {
+        if (!validateUniversalAddress(address, params.chain)) {
           throw new ValidationError("Valid address is required");
         }
         const qs = new URLSearchParams();
@@ -1861,7 +2396,8 @@ ${bytes.length}`;
         setIfPresent("sinceDays", params.sinceDays);
         setIfPresent("since", params.since);
         setIfPresent("limit", params.limit);
-        setCsvIfPresent("select", params.select);
+        setBoolIfPresent("includePrivate", params.includePrivate);
+        setBoolIfPresent("includeQHashes", params.includeQHashes);
         setIfPresent("referenceType", params.referenceType);
         setIfPresent("referenceId", params.referenceId);
         setIfPresent("tag", params.tag);
@@ -1875,7 +2411,6 @@ ${bytes.length}`;
         setIfPresent("domain", params.domain);
         setIfPresent("minBalance", params.minBalance);
         setIfPresent("provider", params.provider);
-        setIfPresent("handle", params.handle);
         setIfPresent("ownerAddress", params.ownerAddress);
         setIfPresent("riskLevel", params.riskLevel);
         setBoolIfPresent("sanctioned", params.sanctioned);
@@ -1883,9 +2418,40 @@ ${bytes.length}`;
         setIfPresent("primaryWalletAddress", params.primaryWalletAddress);
         setIfPresent("secondaryWalletAddress", params.secondaryWalletAddress);
         setIfPresent("verificationMethod", params.verificationMethod);
-        setIfPresent("traitPath", params.traitPath);
-        setIfPresent("traitGte", params.traitGte);
-        const response = await this._makeRequest("GET", `/api/v1/proofs/gate/check?${qs.toString()}`);
+        let headersOverride = null;
+        if (params.includePrivate === true) {
+          const provided = params.privateAuth && typeof params.privateAuth === "object" ? params.privateAuth : null;
+          let auth = provided;
+          if (!auth) {
+            const walletCandidate = params.wallet || this._getDefaultBrowserWallet();
+            if (walletCandidate) {
+              auth = await this._buildPrivateGateAuth({
+                address,
+                wallet: walletCandidate,
+                chain: params.chain,
+                signatureMethod: params.signatureMethod
+              });
+            }
+          }
+          if (!auth) {
+          } else {
+            const normalizedAuthWallet = this._normalizeIdentity(auth.walletAddress);
+            const normalizedAddress = this._normalizeIdentity(address);
+            if (!normalizedAuthWallet || normalizedAuthWallet !== normalizedAddress) {
+              throw new ValidationError("privateAuth.walletAddress must match address when includePrivate=true");
+            }
+            const authChain = typeof auth.chain === "string" && auth.chain.includes(":") ? auth.chain.trim() : null;
+            const authSignatureMethod = typeof auth.signatureMethod === "string" && auth.signatureMethod.trim() ? auth.signatureMethod.trim() : null;
+            headersOverride = {
+              "x-wallet-address": String(auth.walletAddress),
+              "x-signature": String(auth.signature),
+              "x-signed-timestamp": String(auth.signedTimestamp),
+              ...authChain ? { "x-chain": authChain } : {},
+              ...authSignatureMethod ? { "x-signature-method": authSignatureMethod } : {}
+            };
+          }
+        }
+        const response = await this._makeRequest("GET", `/api/v1/proofs/check?${qs.toString()}`, null, headersOverride);
         if (!response.success) {
           throw new ApiError(`Gate check failed: ${response.error?.message || "Unknown error"}`, response.error);
         }
@@ -1909,7 +2475,7 @@ ${bytes.length}`;
        *   Supports verifier-specific:
        *     - NFT/Token: 'contractAddress', 'tokenId', 'chainId', 'ownerAddress', 'minBalance'
        *     - DNS: 'domain', 'walletAddress'
-       *     - Wallet-link: 'primaryWalletAddress', 'secondaryWalletAddress', 'chainId'
+       *     - Wallet-link: 'primaryWalletAddress', 'secondaryWalletAddress', 'chain', 'signatureMethod'
        *     - Contract-ownership: 'contractAddress', 'chainId', 'owner', 'verificationMethod'
        *   Note: contentHash matching uses approximation in SDK; for exact SHA-256 matching, use backend API
        * @param {Array} [params.proofs] - Pre-fetched proofs (skip API call)
@@ -1926,7 +2492,7 @@ ${bytes.length}`;
        */
       async checkGate(params) {
         const { walletAddress, requirements, proofs: preloadedProofs } = params;
-        if (!walletAddress || !/^0x[a-fA-F0-9]{40}$/i.test(walletAddress)) {
+        if (!validateUniversalAddress(walletAddress)) {
           throw new ValidationError("Valid walletAddress is required");
         }
         if (!Array.isArray(requirements) || requirements.length === 0) {
@@ -2120,16 +2686,20 @@ ${bytes.length}`;
        * @private
        */
       _formatResponse(response) {
-        const qHash = response?.data?.qHash || response?.qHash || response?.data?.resource?.qHash || response?.data?.id;
+        const proofId = response?.data?.proofId || response?.proofId || response?.data?.resource?.proofId || response?.data?.qHash || response?.qHash || response?.data?.resource?.qHash || response?.data?.id;
+        const qHash = response?.data?.qHash || response?.qHash || response?.data?.resource?.qHash || proofId || response?.data?.id;
+        const finalProofId = proofId || qHash || null;
+        const finalQHash = qHash || proofId || finalProofId;
         const status = response?.data?.status || response?.status || response?.data?.resource?.status || (response?.success ? "completed" : "unknown");
         return {
           success: response.success,
-          qHash,
+          proofId: finalProofId,
+          qHash: finalQHash,
           status,
           data: response.data,
           message: response.message,
           timestamp: Date.now(),
-          statusUrl: qHash ? `${this.baseUrl}/api/v1/verification/status/${qHash}` : null
+          statusUrl: finalProofId ? `${this.baseUrl}/api/v1/verification/status/${finalProofId}` : null
         };
       }
       /**
@@ -2173,11 +2743,16 @@ __export(sdk_exports, {
   AuthenticationError: () => AuthenticationError,
   ConfigurationError: () => ConfigurationError,
   DAY: () => DAY,
+  GATE_AGENT_DELEGATION: () => GATE_AGENT_DELEGATION,
+  GATE_AGENT_IDENTITY: () => GATE_AGENT_IDENTITY,
+  GATE_CONTENT_MODERATION: () => GATE_CONTENT_MODERATION,
   GATE_CONTRACT_ADMIN: () => GATE_CONTRACT_ADMIN,
   GATE_DOMAIN_OWNER: () => GATE_DOMAIN_OWNER,
   GATE_LINKED_WALLETS: () => GATE_LINKED_WALLETS,
   GATE_NFT_HOLDER: () => GATE_NFT_HOLDER,
+  GATE_PSEUDONYM: () => GATE_PSEUDONYM,
   GATE_TOKEN_HOLDER: () => GATE_TOKEN_HOLDER,
+  GATE_WALLET_RISK: () => GATE_WALLET_RISK,
   HOUR: () => HOUR,
   MONTH: () => MONTH,
   NEUS_CONSTANTS: () => NEUS_CONSTANTS,
@@ -2205,9 +2780,15 @@ __export(sdk_exports, {
   isSupportedChain: () => isSupportedChain,
   isTerminalStatus: () => isTerminalStatus,
   normalizeAddress: () => normalizeAddress,
+  resolveDID: () => resolveDID,
+  resolveZkPassportConfig: () => resolveZkPassportConfig,
+  signMessage: () => signMessage,
+  standardizeVerificationRequest: () => standardizeVerificationRequest,
+  toHexUtf8: () => toHexUtf8,
   validateQHash: () => validateQHash,
   validateSignatureComponents: () => validateSignatureComponents,
   validateTimestamp: () => validateTimestamp,
+  validateUniversalAddress: () => validateUniversalAddress,
   validateVerifierPayload: () => validateVerifierPayload,
   validateWalletAddress: () => validateWalletAddress,
   withRetry: () => withRetry
@@ -2237,9 +2818,21 @@ var GATE_DOMAIN_OWNER = [
 var GATE_LINKED_WALLETS = [
   { verifierId: "wallet-link" }
 ];
+var GATE_AGENT_IDENTITY = [
+  { verifierId: "agent-identity" }
+];
 var GATE_AGENT_DELEGATION = [
   { verifierId: "agent-delegation", maxAgeMs: 7 * DAY }
 ];
+var GATE_CONTENT_MODERATION = [
+  { verifierId: "ai-content-moderation" }
+];
+var GATE_WALLET_RISK = [
+  { verifierId: "wallet-risk" }
+];
+var GATE_PSEUDONYM = [
+  { verifierId: "ownership-pseudonym" }
+];
 function createGate(requirements) {
   return requirements.map((req) => {
     if (typeof req === "string") {
@@ -2275,11 +2868,16 @@ var sdk_default = {
   AuthenticationError,
   ConfigurationError,
   DAY,
+  GATE_AGENT_DELEGATION,
+  GATE_AGENT_IDENTITY,
+  GATE_CONTENT_MODERATION,
   GATE_CONTRACT_ADMIN,
   GATE_DOMAIN_OWNER,
   GATE_LINKED_WALLETS,
   GATE_NFT_HOLDER,
+  GATE_PSEUDONYM,
   GATE_TOKEN_HOLDER,
+  GATE_WALLET_RISK,
   HOUR,
   MONTH,
   NEUS_CONSTANTS,
@@ -2306,9 +2904,15 @@ var sdk_default = {
   isSupportedChain,
   isTerminalStatus,
   normalizeAddress,
+  resolveDID,
+  resolveZkPassportConfig,
+  signMessage,
+  standardizeVerificationRequest,
+  toHexUtf8,
   validateQHash,
   validateSignatureComponents,
   validateTimestamp,
+  validateUniversalAddress,
   validateVerifierPayload,
   validateWalletAddress,
   withRetry