@neus/sdk 1.1.0 → 1.1.2

package/widgets/verify-gate/dist/VerifyGate.js

@@ -8,18 +8,35 @@ import { NeusClient } from "@neus/sdk/client";
 var HOSTED_CHECKOUT_MESSAGE_TYPE = "neus_checkout_done";
 function buildHostedCheckoutUrl({
   hostedCheckoutUrl,
-  verifierList,
+  verifierList = [],
   returnUrl,
   origin,
   oauthProvider,
   campaignTitle,
-  campaignMessage
+  campaignMessage,
+  appId,
+  billingWallet,
+  gateId
 }) {
   const checkoutUrl = new URL(hostedCheckoutUrl);
-  checkoutUrl.searchParams.set("verifiers", verifierList.join(","));
   checkoutUrl.searchParams.set("mode", "popup");
   checkoutUrl.searchParams.set("returnUrl", returnUrl);
   checkoutUrl.searchParams.set("origin", origin);
+  const gateIdTrimmed = typeof gateId === "string" ? gateId.trim() : "";
+  if (gateIdTrimmed) {
+    checkoutUrl.searchParams.set("gateId", gateIdTrimmed);
+  } else {
+    const verifiers = Array.isArray(verifierList) ? verifierList.filter(Boolean) : [];
+    if (verifiers.length > 0) {
+      checkoutUrl.searchParams.set("verifiers", verifiers.join(","));
+    }
+    if (typeof appId === "string" && appId.trim()) {
+      checkoutUrl.searchParams.set("appId", appId.trim());
+    }
+    if (typeof billingWallet === "string" && billingWallet.trim()) {
+      checkoutUrl.searchParams.set("billingWallet", billingWallet.trim().toLowerCase());
+    }
+  }
   if (typeof oauthProvider === "string" && oauthProvider.trim()) {
     checkoutUrl.searchParams.set("oauthProvider", oauthProvider.trim());
   }
@@ -37,16 +54,17 @@ function buildHostedCheckoutRedirectUrl(popupCheckoutUrl) {
   return checkoutUrl.toString();
 }
 
-// widgets/verify-gate/mergeCreateProofOptions.js
-function mergeVerifyGateCreateProofOptions(proofOptions, verifierOptions) {
-  return {
-    privacyLevel: "private",
-    publicDisplay: false,
-    storeOriginalContent: true,
-    ...proofOptions && typeof proofOptions === "object" ? proofOptions : {},
-    ...verifierOptions ? { verifierOptions } : {}
-  };
+// brand-mark.js
+var NEUS_BRAND_PACK_VERSION = "2026-06-03-mark-og-finalize-v1";
+var NEUS_MARK_CDN_ORIGIN = "https://neus.network";
+var PACK_BASE = `${NEUS_MARK_CDN_ORIGIN}/images/neus-brand-pack`;
+var v = encodeURIComponent(NEUS_BRAND_PACK_VERSION);
+function withBrandPackVersion(file) {
+  const name = file.replace(/^\//, "");
+  return `${PACK_BASE}/${name}?v=${v}`;
 }
+var NEUS_DEFAULT_MARK_URL = withBrandPackVersion("favicon.svg");
+var NEUS_DEFAULT_OG_IMAGE_URL = withBrandPackVersion("og-default-1200x630-neus.png");
 
 // widgets/verify-gate/VerifyGate.jsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -74,37 +92,6 @@ if (typeof document !== "undefined") {
     document.head.appendChild(el);
   }
 }
-var DEFAULT_MAX_AGE_MS_BY_VERIFIER = {
-  "ownership-dns-txt": 60 * 60 * 1e3,
-  "contract-ownership": 60 * 60 * 1e3,
-  "nft-ownership": 60 * 60 * 1e3,
-  "token-holding": 60 * 60 * 1e3,
-  "wallet-risk": 60 * 60 * 1e3,
-  "agent-delegation": 7 * 24 * 60 * 60 * 1e3
-};
-var maxAgeMsForVerifier = (verifierId, overrideMs) => {
-  if (typeof overrideMs === "number") return overrideMs;
-  return DEFAULT_MAX_AGE_MS_BY_VERIFIER[verifierId];
-};
-var CREATABLE_VERIFIERS = /* @__PURE__ */ new Set([
-  "ownership-basic",
-  "ownership-pseudonym",
-  "ownership-dns-txt",
-  "contract-ownership",
-  "nft-ownership",
-  "token-holding",
-  "wallet-link",
-  "wallet-risk",
-  "agent-identity",
-  "agent-delegation",
-  "ai-content-moderation"
-]);
-var INTERACTIVE_VERIFIERS = /* @__PURE__ */ new Set([
-  "ownership-social",
-  "ownership-org-oauth",
-  "proof-of-human"
-]);
-var HOSTED_WHEN_INCOMPLETE = /* @__PURE__ */ new Set(["wallet-link"]);
 var DEFAULT_HOSTED_CHECKOUT_URL = "https://neus.network/verify";
 var VERIFY_GATE_DEFAULT_ERROR = "Something went wrong. Please try again.";
 function getVerifyGateUserError(err) {
@@ -159,42 +146,40 @@ function VerifyGateInlineSpinner({ size = 16 }) {
     }
   );
 }
-function NeusLogo({ size = 16, onPrimaryFill = false }) {
+function NeusLogo({ size = 16 }) {
   return /* @__PURE__ */ jsx(
-    "span",
+    "img",
     {
+      src: NEUS_DEFAULT_MARK_URL,
+      alt: "",
       "aria-hidden": "true",
+      width: size,
+      height: size,
       style: {
-        display: "inline-flex",
-        alignItems: "center",
-        justifyContent: "center",
-        width: `${size}px`,
-        height: `${size}px`,
-        borderRadius: "4px",
-        border: `1px solid ${onPrimaryFill ? "rgba(10, 10, 10, 0.35)" : "currentColor"}`,
-        color: onPrimaryFill ? "#0a0a0a" : "currentColor",
-        fontSize: `${Math.max(9, Math.round(size * 0.55))}px`,
-        fontWeight: 700,
-        lineHeight: 1
-      },
-      children: "N"
+        width: size,
+        height: size,
+        display: "block",
+        borderRadius: 4,
+        flexShrink: 0,
+        objectFit: "contain",
+        background: "transparent"
+      }
     }
   );
 }
 function VerifyGate({
+  gateId = void 0,
   requiredVerifiers = ["ownership-basic"],
   onVerified = void 0,
   apiUrl = void 0,
   appId = void 0,
+  billingWallet = void 0,
   paymentSignature = void 0,
   extraHeaders = void 0,
   hostedCheckoutUrl = void 0,
   oauthProvider = void 0,
   style = void 0,
   children = void 0,
-  verifierOptions = void 0,
-  verifierData = void 0,
-  proofOptions = void 0,
   showBrand = false,
   disabled = false,
   buttonText = void 0,
@@ -202,7 +187,6 @@ function VerifyGate({
   qHash: qHashProp = null,
   strategy = "reuse-or-create",
   checkExisting = true,
-  maxProofAgeMs = void 0,
   allowPrivateReuse = true,
   campaignTitle = void 0,
   campaignMessage = void 0,
@@ -219,27 +203,18 @@ function VerifyGate({
   const [walletAddress, setWalletAddress] = useState(null);
   const [existingProofs, setExistingProofs] = useState(null);
   const [operation, setOperation] = useState("verify");
+  const resolvedGateId = typeof gateId === "string" ? gateId.trim() : "";
   const client = useMemo(
-    () => new NeusClient({ apiUrl, appId, paymentSignature, extraHeaders }),
-    [apiUrl, appId, paymentSignature, extraHeaders]
+    () => new NeusClient({ apiUrl, appId: resolvedGateId ? void 0 : appId, billingWallet: resolvedGateId ? void 0 : billingWallet, paymentSignature, extraHeaders }),
+    [apiUrl, appId, billingWallet, paymentSignature, extraHeaders, resolvedGateId]
   );
   const verifierList = useMemo(() => {
+    if (resolvedGateId) return [];
     return Array.isArray(requiredVerifiers) && requiredVerifiers.length > 0 ? requiredVerifiers : ["ownership-basic"];
-  }, [requiredVerifiers]);
+  }, [requiredVerifiers, resolvedGateId]);
   const primaryVerifier = verifierList[0];
   const qHash = qHashProp || null;
   const resolvedQHash = qHash;
-  const hasInteractiveVerifier = useMemo(
-    () => verifierList.some((verifierId) => {
-      if (INTERACTIVE_VERIFIERS.has(verifierId)) return true;
-      if (HOSTED_WHEN_INCOMPLETE.has(verifierId)) {
-        const data = verifierData && verifierData[verifierId];
-        if (!data || !data.secondaryWalletAddress || !data.signature) return true;
-      }
-      return false;
-    }),
-    [verifierList, verifierData]
-  );
   const resolvedHostedCheckoutUrl = useMemo(() => {
     if (typeof hostedCheckoutUrl === "string" && hostedCheckoutUrl.trim()) {
       return hostedCheckoutUrl.trim();
@@ -253,7 +228,7 @@ function VerifyGate({
     }
     return DEFAULT_HOSTED_CHECKOUT_URL;
   }, [apiUrl, hostedCheckoutUrl]);
-  const shouldCheckExisting = checkExisting && strategy !== "fresh";
+  const shouldCheckExisting = !resolvedGateId && checkExisting && strategy !== "fresh";
   const inferChainFromAddress = useCallback((address) => {
     const raw = String(address || "").trim();
     if (!raw) return void 0;
@@ -262,11 +237,8 @@ function VerifyGate({
     return "solana:mainnet";
   }, [chain]);
   const buildGateRequirements = useCallback(() => {
-    return verifierList.map((verifierId) => ({
-      verifierId,
-      ...maxAgeMsForVerifier(verifierId, maxProofAgeMs) && { maxAgeMs: maxAgeMsForVerifier(verifierId, maxProofAgeMs) }
-    }));
-  }, [verifierList, maxProofAgeMs]);
+    return verifierList.map((verifierId) => ({ verifierId }));
+  }, [verifierList]);
   const applySatisfiedGateResult = useCallback((gateResult, address) => {
     if (!gateResult?.satisfied) return false;
     setNotice(null);
@@ -397,7 +369,10 @@ function VerifyGate({
       origin,
       oauthProvider,
       campaignTitle,
-      campaignMessage
+      campaignMessage,
+      gateId: resolvedGateId || void 0,
+      appId: resolvedGateId ? void 0 : appId,
+      billingWallet: resolvedGateId ? void 0 : billingWallet
     });
     let expectedOrigin = null;
     try {
@@ -451,7 +426,7 @@ function VerifyGate({
       };
       window.addEventListener("message", onMessage);
     });
-  }, [resolvedHostedCheckoutUrl, verifierList, oauthProvider, campaignTitle, campaignMessage]);
+  }, [resolvedHostedCheckoutUrl, verifierList, oauthProvider, campaignTitle, campaignMessage, appId, billingWallet, resolvedGateId]);
   useEffect(() => {
     onStateChange?.(state);
   }, [state, onStateChange]);
@@ -538,118 +513,25 @@ function VerifyGate({
         setState("idle");
         setNotice("No matching proof was found. Create a proof to continue.");
       } else {
-        if (hasInteractiveVerifier) {
-          setOperation("verify");
-          setIsProcessing(true);
-          setState("interactive-checkout");
-          onStateChange?.("interactive-checkout");
-          const checkoutResult = await launchHostedCheckout();
-          const checkoutQHash = checkoutResult?.qHash || null;
-          const handoffWallet = typeof checkoutResult?.walletAddress === "string" && checkoutResult.walletAddress.trim() || walletAddress && String(walletAddress).trim() || "";
-          setState("verified");
-          dispatchNeusProofCreatedForHost({
-            qHash: checkoutQHash,
-            walletAddress: handoffWallet
-          });
-          onVerified?.({
-            qHash: checkoutQHash,
-            verifierIds: verifierList,
-            existing: false,
-            mode: "create",
-            eligible: checkoutResult?.eligible !== false,
-            proofUrl: checkoutResult?.proofUrl || (checkoutQHash ? `${apiUrl || "https://api.neus.network"}/api/v1/proofs/${checkoutQHash}` : null)
-          });
-          return;
-        }
         setOperation("verify");
         setIsProcessing(true);
-        setState("signing");
-        const resolvedProofOptions = mergeVerifyGateCreateProofOptions(
-          proofOptions,
-          verifierOptions
-        );
-        const buildDataForVerifier = (verifierId) => {
-          if (!CREATABLE_VERIFIERS.has(verifierId)) {
-            throw new Error(
-              "This check requires the hosted verifier."
-            );
-          }
-          const explicit = verifierData && verifierData[verifierId];
-          if (explicit && typeof explicit === "object") return explicit;
-          if (verifierId === "ownership-basic") {
-            return null;
-          }
-          if (verifierId === "wallet-risk") {
-            return {};
-          }
-          if (verifierId === "wallet-link") {
-            if (!explicit?.secondaryWalletAddress || !explicit?.signature || !explicit?.chain || !explicit?.signatureMethod) {
-              throw new Error(
-                "Missing required wallet details."
-              );
-            }
-            return explicit;
-          }
-          throw new Error("Missing required verification details.");
-        };
-        const verifyOne = async (verifierId) => {
-          const dataForVerifier = buildDataForVerifier(verifierId);
-          const params = verifierId === "ownership-basic" && dataForVerifier === null ? {
-            verifier: "ownership-basic",
-            content: (typeof verifierData?.["ownership-basic"] === "string" ? verifierData["ownership-basic"] : verifierData?.["ownership-basic"]?.content) || `NEUS verification (${verifierId})`,
-            options: resolvedProofOptions
-          } : {
-            verifier: verifierId,
-            data: dataForVerifier,
-            options: resolvedProofOptions
-          };
-          setState("signing");
-          const created = await client.verify({
-            ...params,
-            wallet: wallet || (typeof window !== "undefined" ? window.ethereum : void 0)
-          });
-          setState("verifying");
-          const qHashToCheck = created.qHash || created?.data?.qHash;
-          const final = await client.pollProofStatus(qHashToCheck, { interval: 3e3, timeout: 6e4 });
-          const verifiedVerifiers = final?.data?.verifiedVerifiers || [];
-          const verifierResult = verifiedVerifiers.find((v) => v.verifierId === verifierId);
-          if (!verifierResult || verifierResult.verified !== true) {
-            throw new Error("Verification could not be completed.");
-          }
-          const hubTx = final?.data?.hubTransaction || {};
-          const crosschain = final?.data?.crosschain || {};
-          const txHash = hubTx?.txHash || crosschain?.hubTxHash || null;
-          const finalQHash = final?.qHash || qHashToCheck;
-          return {
-            verifierId,
-            qHash: finalQHash,
-            address: final?.data?.walletAddress,
-            txHash,
-            verifiedVerifiers,
-            proofUrl: final?.proofUrl
-          };
-        };
-        const results = [];
-        for (const verifierId of verifierList) {
-          results.push(await verifyOne(verifierId));
-        }
+        setState("interactive-checkout");
+        onStateChange?.("interactive-checkout");
+        const checkoutResult = await launchHostedCheckout();
+        const checkoutQHash = checkoutResult?.qHash || null;
+        const handoffWallet = typeof checkoutResult?.walletAddress === "string" && checkoutResult.walletAddress.trim() || walletAddress && String(walletAddress).trim() || "";
         setState("verified");
-        const last = results[results.length - 1];
-        const lastQHash = last?.qHash || null;
-        const handoffAddr = last?.address && String(last.address).trim() || walletAddress && String(walletAddress).trim() || "";
         dispatchNeusProofCreatedForHost({
-          qHash: lastQHash,
-          walletAddress: handoffAddr
+          qHash: checkoutQHash,
+          walletAddress: handoffWallet
         });
         onVerified?.({
-          qHash: lastQHash,
-          qHashes: results.map((r) => r.qHash).filter(Boolean),
-          address: last?.address,
-          txHash: last?.txHash,
+          qHash: checkoutQHash,
           verifierIds: verifierList,
-          verifiedVerifiers: last?.verifiedVerifiers,
-          proofUrl: last?.proofUrl,
-          results
+          existing: false,
+          mode: "create",
+          eligible: checkoutResult?.eligible !== false,
+          proofUrl: checkoutResult?.proofUrl || (checkoutQHash ? `${apiUrl || "https://api.neus.network"}/api/v1/proofs/${checkoutQHash}` : null)
         });
       }
     } catch (err) {
@@ -667,12 +549,8 @@ function VerifyGate({
     mode,
     resolvedQHash,
     verifierList,
-    hasInteractiveVerifier,
     client,
     apiUrl,
-    verifierOptions,
-    verifierData,
-    proofOptions,
     launchHostedCheckout,
     onVerified,
     onError,
@@ -814,7 +692,7 @@ function VerifyGate({
           style: getButtonStyle(),
           children: [
             (state === "signing" || state === "verifying" || state === "interactive-checkout") && /* @__PURE__ */ jsx(VerifyGateInlineSpinner, { size: 16 }),
-            showBrand && state === "idle" && /* @__PURE__ */ jsx(NeusLogo, { size: 16, onPrimaryFill: true }),
+            showBrand && state === "idle" && /* @__PURE__ */ jsx(NeusLogo, { size: 16 }),
             state === "verified" && /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { fillRule: "evenodd", d: "M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z", clipRule: "evenodd" }) }),
             /* @__PURE__ */ jsx("span", { className: "neus-vg__label", style: { color: "inherit" }, children: getLabel() })
           ]
@@ -871,7 +749,7 @@ function VerifyGate({
       disabled: disabled || isProcessing,
       children: [
         (state === "signing" || state === "verifying" || state === "interactive-checkout") && /* @__PURE__ */ jsx(VerifyGateInlineSpinner, { size: 16 }),
-        showBrand && state === "idle" && /* @__PURE__ */ jsx(NeusLogo, { size: 16, onPrimaryFill: true }),
+        showBrand && state === "idle" && /* @__PURE__ */ jsx(NeusLogo, { size: 16 }),
         state === "verified" && /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { fillRule: "evenodd", d: "M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z", clipRule: "evenodd" }) }),
         /* @__PURE__ */ jsx("span", { className: "neus-vg__label", style: { color: "inherit" }, children: getLabel() }),
         error && /* @__PURE__ */ jsxs("span", { style: { opacity: 0.8, marginLeft: "8px" }, children: [

package/CHANGELOG.md

@@ -1,3 +0,0 @@
-# Changelog
-
-Release notes: [github.com/neus/network/blob/main/CHANGELOG.md](https://github.com/neus/network/blob/main/CHANGELOG.md)