@neus/sdk 1.0.4 → 1.0.6

package/cjs/gates.cjs

@@ -45,36 +45,16 @@ var DAY = 24 * HOUR;
 var WEEK = 7 * DAY;
 var MONTH = 30 * DAY;
 var YEAR = 365 * DAY;
-var GATE_NFT_HOLDER = [
-  { verifierId: "nft-ownership" }
-];
-var GATE_TOKEN_HOLDER = [
-  { verifierId: "token-holding" }
-];
-var GATE_CONTRACT_ADMIN = [
-  { verifierId: "contract-ownership", maxAgeMs: HOUR }
-];
-var GATE_DOMAIN_OWNER = [
-  { verifierId: "ownership-dns-txt" }
-];
-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" }
-];
+var GATE_NFT_HOLDER = [{ verifierId: "nft-ownership" }];
+var GATE_TOKEN_HOLDER = [{ verifierId: "token-holding" }];
+var GATE_CONTRACT_ADMIN = [{ verifierId: "contract-ownership", maxAgeMs: HOUR }];
+var GATE_DOMAIN_OWNER = [{ verifierId: "ownership-dns-txt" }];
+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") {
@@ -98,13 +78,11 @@ function combineGates(...gates) {
   return combined;
 }
 var gates_default = {
-  // Time constants
   HOUR,
   DAY,
   WEEK,
   MONTH,
   YEAR,
-  // Recipe gates
   GATE_NFT_HOLDER,
   GATE_TOKEN_HOLDER,
   GATE_CONTRACT_ADMIN,
@@ -115,7 +93,6 @@ var gates_default = {
   GATE_CONTENT_MODERATION,
   GATE_WALLET_RISK,
   GATE_PSEUDONYM,
-  // Helpers
   createGate,
   combineGates
 };

package/cjs/index.cjs

@@ -322,7 +322,6 @@ function createVerificationData(content, owner, reference = null) {
     content,
     owner: validateWalletAddress(owner) ? owner.toLowerCase() : owner,
     reference: reference || {
-      // Must be a valid backend enum value; 'content' is not supported.
       type: "other",
       id: stableRefId(content)
     }
@@ -1034,9 +1033,7 @@ var init_utils = __esm({
       }
     };
     NEUS_CONSTANTS = {
-      /** Default EVM chain id for NEUS protocol signing context (`HUB_CHAIN_ID` name kept for compatibility). */
       HUB_CHAIN_ID: 84532,
-      // Supported target chains for cross-chain propagation
       TESTNET_CHAINS: [
         11155111,
         // Ethereum Sepolia
@@ -1047,15 +1044,12 @@ var init_utils = __esm({
         80002
         // Polygon Amoy
       ],
-      // API endpoints
       API_BASE_URL: "https://api.neus.network",
       API_VERSION: "v1",
-      // Timeouts and limits
       SIGNATURE_MAX_AGE_MS: 5 * 60 * 1e3,
       // 5 minutes
       REQUEST_TIMEOUT_MS: 30 * 1e3,
       // 30 seconds
-      // Default verifier set for quick starts
       DEFAULT_VERIFIERS: [
         "ownership-basic",
         "nft-ownership",
@@ -1073,7 +1067,21 @@ __export(client_exports, {
   PORTABLE_PROOF_SIGNER_HEADER: () => PORTABLE_PROOF_SIGNER_HEADER,
   constructVerificationMessage: () => constructVerificationMessage
 });
-var FALLBACK_PUBLIC_VERIFIER_CATALOG, EVM_ADDRESS_RE, validateVerifierData, NeusClient;
+function normalizeWalletLinkRelationshipType(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return WALLET_LINK_RELATIONSHIP_TYPES.has(normalized) ? normalized : "linked";
+}
+function normalizeBrowserSignerString(raw) {
+  if (raw === null || raw === void 0) {
+    return null;
+  }
+  if (typeof raw === "string") {
+    const t = raw.trim();
+    return t.length > 0 ? t : null;
+  }
+  return null;
+}
+var FALLBACK_PUBLIC_VERIFIER_CATALOG, EVM_ADDRESS_RE, WALLET_LINK_RELATIONSHIP_TYPES, validateVerifierData, NeusClient;
 var init_client = __esm({
   "client.js"() {
     "use strict";
@@ -1096,6 +1104,7 @@ var init_client = __esm({
       "ai-content-moderation": { supportsDirectApi: true }
     };
     EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
+    WALLET_LINK_RELATIONSHIP_TYPES = /* @__PURE__ */ new Set(["primary", "personal", "org", "affiliate", "agent", "linked"]);
     validateVerifierData = (verifierId, data) => {
       if (!data || typeof data !== "object") {
         return { valid: false, error: "Data object is required" };
@@ -1424,26 +1433,49 @@ var init_client = __esm({
         if (!wallet) {
           throw new ConfigurationError("No wallet provider available");
         }
-        if (wallet.address) {
-          return { signerWalletAddress: wallet.address, provider: wallet };
+        if (wallet.address !== null && wallet.address !== void 0) {
+          const s = normalizeBrowserSignerString(
+            typeof wallet.address === "string" ? wallet.address : null
+          );
+          if (s) {
+            return { signerWalletAddress: s, provider: wallet };
+          }
         }
         if (wallet.publicKey && typeof wallet.publicKey.toBase58 === "function") {
-          return { signerWalletAddress: wallet.publicKey.toBase58(), provider: wallet };
+          const b58 = wallet.publicKey.toBase58();
+          const s = normalizeBrowserSignerString(typeof b58 === "string" ? b58 : null);
+          if (s) {
+            return { signerWalletAddress: s, provider: wallet };
+          }
         }
         if (typeof wallet.getAddress === "function") {
-          const signerWalletAddress = await wallet.getAddress().catch(() => null);
-          return { signerWalletAddress, provider: wallet };
+          const got = await wallet.getAddress().catch(() => null);
+          const s = normalizeBrowserSignerString(
+            got === null || got === void 0 ? null : typeof got === "string" ? got : null
+          );
+          if (s) {
+            return { signerWalletAddress: s, provider: wallet };
+          }
         }
         if (wallet.selectedAddress || wallet.request) {
           const provider = wallet;
           if (wallet.selectedAddress) {
-            return { signerWalletAddress: wallet.selectedAddress, provider };
+            const s2 = normalizeBrowserSignerString(
+              typeof wallet.selectedAddress === "string" ? wallet.selectedAddress : null
+            );
+            if (s2) {
+              return { signerWalletAddress: s2, 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 };
+          const s = normalizeBrowserSignerString(accounts[0]);
+          if (!s) {
+            throw new ConfigurationError("No wallet accounts available");
+          }
+          return { signerWalletAddress: s, provider };
         }
         throw new ConfigurationError("Invalid wallet provider");
       }
@@ -1506,47 +1538,74 @@ var init_client = __esm({
           signatureMethod: params.signatureMethod
         });
       }
-      /**
-       * Create a verification proof.
-       *
-       * Supports two paths:
-       *   - **Auto:** Supply `verifier`, `content`, and/or `data` with an optional
-       *     `wallet` provider. The SDK performs signing in the client.
-       *   - **Manual:** Supply pre-signed `verifierIds`, `data`, `walletAddress`,
-       *     `signature`, and `signedTimestamp`.
-       *
-       * @param {Object} params - Verification parameters
-       * @param {string} [params.verifier] - Verifier ID (auto path, e.g. 'ownership-basic')
-       * @param {string} [params.content] - Content to verify (auto path)
-       * @param {Object} [params.data] - Structured verification data
-       * @param {Object} [params.wallet] - Wallet provider (auto path)
-       * @param {Object} [params.options] - Additional options
-       * @param {Array<string>} [params.verifierIds] - Array of verifier IDs (manual path)
-       * @param {string} [params.walletAddress] - Wallet address that signed the request (manual path)
-       * @param {string} [params.signature] - EIP-191 signature (manual path)
-       * @param {number} [params.signedTimestamp] - Unix timestamp when signature was created (manual path)
-       * @param {number} [params.chainId] - EVM signing-context hint; when omitted, resolved to the NEUS protocol primary chain for signing
-       * @returns {Promise<Object>} Verification result with proofId
-       *
-       * @example
-       * // Auto path
-       * const proof = await client.verify({
-       *   verifier: 'ownership-basic',
-       *   content: 'Hello World',
-       *   wallet: window.ethereum
-       * });
-       *
-       * @example
-       * // Manual path
-       * const proof = await client.verify({
-       *   verifierIds: ['ownership-basic'],
-       *   data: { content: "My content", owner: walletAddress },
-       *   walletAddress: '0x...',
-       *   signature: '0x...',
-       *   signedTimestamp: Date.now(),
-       *   options: { targetChains: [421614, 11155111] }
-       * });
-       */
+      async createWalletLinkData(params = {}) {
+        const normalizedPrimary = this._normalizeIdentity(params.primaryWalletAddress);
+        const normalizedSecondary = this._normalizeIdentity(params.secondaryWalletAddress);
+        if (!EVM_ADDRESS_RE.test(normalizedPrimary)) {
+          throw new ValidationError("wallet-link requires a valid primaryWalletAddress");
+        }
+        if (!EVM_ADDRESS_RE.test(normalizedSecondary)) {
+          throw new ValidationError("wallet-link requires a valid secondaryWalletAddress");
+        }
+        if (normalizedPrimary === normalizedSecondary) {
+          throw new ValidationError("wallet-link secondaryWalletAddress must differ from primaryWalletAddress");
+        }
+        const providerWallet = params.wallet || this._getDefaultBrowserWallet();
+        const { signerWalletAddress, provider } = await this._resolveWalletSigner(providerWallet);
+        const normalizedSigner = this._normalizeIdentity(signerWalletAddress);
+        if (!EVM_ADDRESS_RE.test(normalizedSigner)) {
+          throw new ValidationError("wallet-link requires an EVM wallet/provider for the secondary wallet");
+        }
+        if (normalizedSigner !== normalizedSecondary) {
+          throw new ValidationError("wallet-link wallet/provider must be connected to secondaryWalletAddress");
+        }
+        const resolvedChain = (() => {
+          const raw = String(params.chain || "").trim();
+          if (!raw) return `eip155:${this._getHubChainId()}`;
+          if (!/^eip155:\d+$/.test(raw)) {
+            throw new ValidationError("wallet-link requires chain in the form eip155:<chainId>");
+          }
+          return raw;
+        })();
+        const signedTimestamp = Number.isFinite(Number(params.signedTimestamp)) && Number(params.signedTimestamp) > 0 ? Number(params.signedTimestamp) : Date.now();
+        const linkData = {
+          primaryAccountId: `${resolvedChain}:${normalizedPrimary}`,
+          secondaryAccountId: `${resolvedChain}:${normalizedSecondary}`,
+          primaryWalletAddress: normalizedPrimary,
+          secondaryWalletAddress: normalizedSecondary
+        };
+        const message = constructVerificationMessage({
+          walletAddress: normalizedSecondary,
+          signedTimestamp,
+          data: linkData,
+          verifierIds: ["wallet-link"],
+          chain: resolvedChain
+        });
+        let signature;
+        try {
+          signature = await signMessage({
+            provider,
+            message,
+            walletAddress: signerWalletAddress
+          });
+        } catch (error) {
+          if (error?.code === 4001) {
+            throw new ValidationError("User rejected wallet-link signature request");
+          }
+          throw new ValidationError(`Failed to sign wallet-link message: ${error?.message || String(error)}`);
+        }
+        const label = String(params.label || "").trim().slice(0, 64);
+        return {
+          primaryWalletAddress: normalizedPrimary,
+          secondaryWalletAddress: normalizedSecondary,
+          signature,
+          chain: resolvedChain,
+          signatureMethod: "eip191",
+          signedTimestamp,
+          relationshipType: normalizeWalletLinkRelationshipType(params.relationshipType),
+          ...label ? { label } : {}
+        };
+      }
       async verify(params) {
         if ((!params?.signature || !params?.walletAddress) && (params?.verifier || params?.content || params?.data)) {
           const { content, verifier = "ownership-basic", data: data2 = null, wallet = null, options: options2 = {} } = params;
@@ -1588,11 +1647,16 @@ var init_client = __esm({
           }
           let walletAddress2, provider;
           if (wallet) {
-            walletAddress2 = wallet.address || wallet.selectedAddress || wallet.walletAddress || (typeof wallet.getAddress === "function" ? await wallet.getAddress() : null);
+            walletAddress2 = wallet.address || wallet.selectedAddress || wallet.walletAddress || (typeof wallet.getAddress === "function" ? await wallet.getAddress().catch(() => null) : 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;
+              let accounts = await provider.request({ method: "eth_accounts" });
+              walletAddress2 = Array.isArray(accounts) && accounts.length > 0 ? accounts[0] : null;
+              if (!walletAddress2) {
+                await provider.request({ method: "eth_requestAccounts" });
+                accounts = await provider.request({ method: "eth_accounts" });
+                walletAddress2 = Array.isArray(accounts) && accounts.length > 0 ? accounts[0] : null;
+              }
             }
           } else {
             if (typeof window === "undefined" || !window.ethereum) {
@@ -1603,6 +1667,15 @@ var init_client = __esm({
             const accounts = await provider.request({ method: "eth_accounts" });
             walletAddress2 = accounts[0];
           }
+          {
+            const normalized = normalizeBrowserSignerString(
+              typeof walletAddress2 === "string" ? walletAddress2 : null
+            );
+            if (!normalized) {
+              throw new ConfigurationError("No wallet accounts available. Connect a wallet to continue.");
+            }
+            walletAddress2 = normalized;
+          }
           let verificationData;
           if (verifier === "ownership-basic") {
             if (data2 && typeof data2 === "object") {
@@ -1754,8 +1827,6 @@ var init_client = __esm({
             verificationData = {
               walletAddress: data2?.walletAddress || walletAddress2,
               ...data2?.provider && { provider: data2.provider },
-              // Mainnet-first semantics: if caller doesn't provide chainId, default to Ethereum mainnet (1).
-              // This avoids accidental testnet semantics for risk providers.
               chainId: typeof data2?.chainId === "number" && Number.isFinite(data2.chainId) ? data2.chainId : 1,
               ...data2?.includeDetails !== void 0 && { includeDetails: data2.includeDetails }
             };
@@ -1777,7 +1848,6 @@ var init_client = __esm({
             data: verificationData,
             verifierIds: verifierIds2,
             chainId: this._getHubChainId()
-            // Protocol-managed chain
           });
           let signature2;
           try {
@@ -1813,6 +1883,7 @@ var init_client = __esm({
                 const hexMsg = toHexUtf82(message);
                 signature2 = await provider.request({ method: "personal_sign", params: [hexMsg, walletAddress2] });
               } catch (e) {
+                void e;
               }
             }
             if (!signature2) {
@@ -1922,7 +1993,6 @@ ${bytes.length}`;
         const optionsPayload = {
           ...options && typeof options === "object" ? options : {},
           targetChains: Array.isArray(options?.targetChains) ? options.targetChains : [],
-          // Privacy and storage options (defaults)
           privacyLevel: options?.privacyLevel || "private",
           publicDisplay: options?.publicDisplay || false,
           storeOriginalContent: typeof options?.storeOriginalContent === "boolean" ? options.storeOriginalContent : true
@@ -1945,16 +2015,6 @@ ${bytes.length}`;
         }
         return this._formatResponse(response);
       }
-      /**
-       * Get proof record by proof receipt id.
-       *
-       * @param {string} proofId - Proof receipt ID (0x + 64 hex).
-       * @returns {Promise<Object>} Proof record and verification state
-       *
-       * @example
-       * const result = await client.getProof('0x...');
-       * console.log('Status:', result.status);
-       */
       async getProof(proofId) {
         if (!proofId || typeof proofId !== "string") {
           throw new ValidationError("proofId is required");
@@ -1965,16 +2025,6 @@ ${bytes.length}`;
         }
         return this._formatResponse(response);
       }
-      /**
-       * Get private proof record with wallet signature
-       *
-       * @param {string} proofId - Proof receipt ID.
-       * @param {Object} wallet - Wallet provider (window.ethereum or ethers Wallet)
-       * @returns {Promise<Object>} Private proof record and verification state
-       *
-       * @example
-       * const privateData = await client.getPrivateProof(proofId, window.ethereum);
-       */
       async getPrivateProof(proofId, wallet = null) {
         if (!proofId || typeof proofId !== "string") {
           throw new ValidationError("proofId is required");
@@ -2042,11 +2092,6 @@ ${bytes.length}`;
         }
         return this._formatResponse(response);
       }
-      /**
-       * Check API health
-       *
-       * @returns {Promise<boolean>} True if API is healthy
-       */
       async isHealthy() {
         try {
           const response = await this._makeRequest("GET", "/api/v1/health");
@@ -2055,19 +2100,10 @@ ${bytes.length}`;
           return false;
         }
       }
-      /**
-       * List available verifiers
-       *
-       * @returns {Promise<string[]>} Array of verifier IDs
-       */
       async getVerifiers() {
         const catalog = await this.getVerifierCatalog();
         return Array.isArray(catalog?.data) ? catalog.data : [];
       }
-      /**
-       * Get the public verifier catalog with per-verifier capabilities.
-       * @returns {Promise<{data: string[], metadata: Record<string, { supportsDirectApi?: boolean }>, meta?: object}>}
-       */
       async getVerifierCatalog() {
         const response = await this._makeRequest("GET", "/api/v1/verification/verifiers");
         if (!response.success) {
@@ -2079,31 +2115,6 @@ ${bytes.length}`;
           meta: response.meta && typeof response.meta === "object" && !Array.isArray(response.meta) ? response.meta : {}
         };
       }
-      /**
-       * POLL PROOF STATUS - Wait for verification completion
-       *
-       * 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} proofId - Proof ID to poll.
-       * @param {Object} [options] - Polling options
-       * @param {number} [options.interval=5000] - Polling interval in ms
-       * @param {number} [options.timeout=120000] - Total timeout in ms
-       * @param {Function} [options.onProgress] - Progress callback function
-       * @returns {Promise<Object>} Final verification status
-       *
-       * @example
-       * const finalStatus = await client.pollProofStatus(proofId, {
-       *   interval: 3000,
-       *   timeout: 60000,
-       *   onProgress: (status) => {
-       *     console.log('Current status:', status.status);
-       *     if (status.crosschain) {
-       *       console.log(`Cross-chain: ${status.crosschain.finalized}/${status.crosschain.totalChains}`);
-       *     }
-       *   }
-       * });
-       */
       async pollProofStatus(proofId, options = {}) {
         const {
           interval = 5e3,
@@ -2148,11 +2159,6 @@ ${bytes.length}`;
         }
         throw new NetworkError(`Polling timeout after ${timeout}ms`, "POLLING_TIMEOUT");
       }
-      /**
-       * DETECT CHAIN ID - Get current wallet chain
-       *
-       * @returns {Promise<number>} Current chain ID
-       */
       async detectChainId() {
         if (typeof window === "undefined" || !window.ethereum) {
           throw new ConfigurationError("No Web3 wallet detected");
@@ -2164,7 +2170,6 @@ ${bytes.length}`;
           throw new NetworkError(`Failed to detect chain ID: ${error.message}`);
         }
       }
-      /** Revoke your own proof (owner-signed) */
       async revokeOwnProof(proofId, wallet) {
         if (!proofId || typeof proofId !== "string") {
           throw new ValidationError("proofId is required");
@@ -2215,22 +2220,6 @@ ${bytes.length}`;
         }
         return true;
       }
-      /**
-       * GET PROOFS BY WALLET - Fetch proofs for a wallet address
-       *
-       * @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)
-       * @param {string} [options.qHash] - Filter to single proof by qHash
-       * @returns {Promise<Object>} Proofs result
-       *
-       * @example
-       * const result = await client.getProofsByWallet('0x...', {
-       *   limit: 50,
-       *   offset: 0
-       * });
-       */
       async getProofsByWallet(walletAddress, options = {}) {
         if (!walletAddress || typeof walletAddress !== "string") {
           throw new ValidationError("walletAddress is required");
@@ -2258,18 +2247,6 @@ ${bytes.length}`;
           nextOffset: response.data?.nextOffset ?? null
         };
       }
-      /**
-       * Get proofs by wallet (owner access)
-       *
-       * Signs an owner-access intent and requests private proofs via signature headers.
-       *
-       * @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
-       * @param {string} [options.qHash] - Filter to single proof by qHash
-       * @param {Object} [wallet] - Optional injected wallet/provider (MetaMask/ethers Wallet)
-       */
       async getPrivateProofsByWallet(walletAddress, options = {}, wallet = null) {
         if (!walletAddress || typeof walletAddress !== "string") {
           throw new ValidationError("walletAddress is required");
@@ -2340,31 +2317,6 @@ ${bytes.length}`;
           nextOffset: response.data?.nextOffset ?? null
         };
       }
-      /**
-       * Gate check (HTTP API) — minimal eligibility response.
-       *
-       * Calls the gate endpoint and returns a **minimal** yes/no response.
-       * By default this checks **public + unlisted** proofs.
-       *
-       * When `includePrivate=true`, this can perform owner-signed private checks
-       * (no full proof payloads returned) by providing a wallet/provider.
-       *
-       * Prefer this over `checkGate()` when you need the smallest, most stable
-       * response shape and do not need full proof payloads.
-       *
-       * @param {Object} params - Gate check query params
-       * @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 {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 (!validateUniversalAddress(address, params.chain)) {
@@ -2436,8 +2388,7 @@ ${bytes.length}`;
               });
             }
           }
-          if (!auth) {
-          } else {
+          if (auth) {
             const normalizedAuthWallet = this._normalizeIdentity(auth.walletAddress);
             const normalizedAddress = this._normalizeIdentity(address);
             if (!normalizedAuthWallet || normalizedAuthWallet !== normalizedAddress) {
@@ -2460,45 +2411,6 @@ ${bytes.length}`;
         }
         return response;
       }
-      /**
-       * CHECK GATE — Local preview against proofs you already have in memory or from `getProofsByWallet`.
-       *
-       * **Not authoritative for access control.** For production allow/deny, use {@link NeusClient#gateCheck}
-       * (`GET /api/v1/proofs/check`), which applies the same rules as the NEUS API. This method is useful for
-       * UI previews, offline-ish flows, or when you already fetched proofs and want a quick match without
-       * another round trip — but it can disagree with the server (e.g. `contentHash` matching uses a local
-       * approximation when proof data only has inline `content`; the API uses the standard server-side hash).
-       *
-       * Gate-first verification: checks if wallet has valid proofs satisfying requirements.
-       * Returns which requirements are missing/expired.
-       *
-       * @param {Object} params - Gate check parameters
-       * @param {string} params.walletAddress - Target wallet
-       * @param {Array<Object>} params.requirements - Array of gate requirements
-       * @param {string} params.requirements[].verifierId - Required verifier ID
-       * @param {number} [params.requirements[].maxAgeMs] - Max proof age in ms (TTL)
-       * @param {boolean} [params.requirements[].optional] - If true, not required for gate satisfaction
-       * @param {number} [params.requirements[].minCount] - Minimum proofs needed (default: 1)
-       * @param {Object} [params.requirements[].match] - Verifier data match criteria
-       *   Supports nested fields: 'reference.type', 'reference.id', 'content', 'contentHash', 'input.*', 'license.*'
-       *   Supports verifier-specific:
-       *     - NFT/Token: 'contractAddress', 'tokenId', 'chainId', 'ownerAddress', 'minBalance'
-       *     - DNS: 'domain', 'walletAddress'
-       *     - 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)
-       * @returns {Promise<Object>} Gate result with satisfied, missing, existing
-       *
-       * @example
-       * // Basic gate check
-       * const result = await client.checkGate({
-       *   walletAddress: '0x...',
-       *   requirements: [
-       *     { verifierId: 'nft-ownership', match: { contractAddress: '0x...' } }
-       *   ]
-       * });
-       */
       async checkGate(params) {
         const { walletAddress, requirements, proofs: preloadedProofs } = params;
         if (!validateUniversalAddress(walletAddress)) {
@@ -2730,7 +2642,6 @@ ${bytes.length}`;
         ];
         return typeof status === "string" && terminalStates.some((state) => status.includes(state));
       }
-      /** SDK logging (opt-in via config.enableLogging) */
       _log(message, data = {}) {
         if (this.config.enableLogging) {
           try {
@@ -2819,36 +2730,16 @@ var DAY = 24 * HOUR;
 var WEEK = 7 * DAY;
 var MONTH = 30 * DAY;
 var YEAR = 365 * DAY;
-var GATE_NFT_HOLDER = [
-  { verifierId: "nft-ownership" }
-];
-var GATE_TOKEN_HOLDER = [
-  { verifierId: "token-holding" }
-];
-var GATE_CONTRACT_ADMIN = [
-  { verifierId: "contract-ownership", maxAgeMs: HOUR }
-];
-var GATE_DOMAIN_OWNER = [
-  { verifierId: "ownership-dns-txt" }
-];
-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" }
-];
+var GATE_NFT_HOLDER = [{ verifierId: "nft-ownership" }];
+var GATE_TOKEN_HOLDER = [{ verifierId: "token-holding" }];
+var GATE_CONTRACT_ADMIN = [{ verifierId: "contract-ownership", maxAgeMs: HOUR }];
+var GATE_DOMAIN_OWNER = [{ verifierId: "ownership-dns-txt" }];
+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") {