@neus/sdk 1.0.10 → 1.1.0

package/client.js

@@ -48,6 +48,13 @@ function normalizeBrowserSignerString(raw) {
   return null;
 }
 
+/** Treats SDK placeholder signatures as absent so the protocol can use session or app-link delegation. */
+function isPlaceholderNeusSignature(signature) {
+  const s = typeof signature === 'string' ? signature.trim() : '';
+  if (!s) return true;
+  return /^0x0+$/i.test(s);
+}
+
 const validateVerifierData = (verifierId, data) => {
   if (!data || typeof data !== 'object') {
     return { valid: false, error: 'Data object is required' };
@@ -232,6 +239,17 @@ const validateVerifierData = (verifierId, data) => {
     if (data.agentType && !['ai', 'bot', 'service', 'automation', 'agent'].includes(data.agentType)) {
       return { valid: false, error: 'agentType must be one of: ai, bot, service, automation, agent' };
     }
+    if (data.defaultRuntime && typeof data.defaultRuntime === 'object') {
+      if (data.defaultRuntime.provider && typeof data.defaultRuntime.provider === 'string' && data.defaultRuntime.provider.length > 64) {
+        return { valid: false, error: 'defaultRuntime.provider must be 64 chars or less' };
+      }
+      if (data.defaultRuntime.model && typeof data.defaultRuntime.model === 'string' && data.defaultRuntime.model.length > 128) {
+        return { valid: false, error: 'defaultRuntime.model must be 128 chars or less' };
+      }
+      if (data.defaultRuntime.mode && typeof data.defaultRuntime.mode === 'string' && data.defaultRuntime.mode.length > 64) {
+        return { valid: false, error: 'defaultRuntime.mode must be 64 chars or less' };
+      }
+    }
     break;
   case 'agent-delegation':
     if (!data.controllerWallet || !validateWalletAddress(data.controllerWallet)) {
@@ -246,6 +264,18 @@ const validateVerifierData = (verifierId, data) => {
     if (data.expiresAt && (typeof data.expiresAt !== 'number' || data.expiresAt < Date.now())) {
       return { valid: false, error: 'expiresAt must be a future timestamp' };
     }
+    if (data.model && typeof data.model === 'string' && data.model.length > 128) {
+      return { valid: false, error: 'model must be 128 chars or less' };
+    }
+    if (data.provider && typeof data.provider === 'string' && data.provider.length > 64) {
+      return { valid: false, error: 'provider must be 64 chars or less' };
+    }
+    if (data.allowedActions && Array.isArray(data.allowedActions) && data.allowedActions.length > 32) {
+      return { valid: false, error: 'allowedActions must have 32 items or less' };
+    }
+    if (data.deniedActions && Array.isArray(data.deniedActions) && data.deniedActions.length > 32) {
+      return { valid: false, error: 'deniedActions must have 32 items or less' };
+    }
     break;
   case 'ai-content-moderation':
     if (!data.content || typeof data.content !== 'string') {
@@ -452,7 +482,9 @@ export class NeusClient {
 
   _getDefaultBrowserWallet() {
     if (typeof window === 'undefined') return null;
-    return window.ethereum || window.solana || (window.phantom && window.phantom.solana) || null;
+    // Legacy convenience fallback only. Non-EVM wallets must be passed explicitly
+    // with CAIP-2 chain context so the SDK does not route them through EVM RPC.
+    return window.ethereum || null;
   }
 
   async _buildPrivateGateAuth({ address, wallet, chain, signatureMethod } = {}) {
@@ -595,8 +627,74 @@ export class NeusClient {
     };
   }
 
+  async verifyFromApp(params) {
+    if (!params || typeof params !== 'object') {
+      throw new ValidationError('verifyFromApp requires a params object');
+    }
+
+    const {
+      user,
+      verifier = 'ownership-basic',
+      content,
+      data: explicitData = null,
+      options = {}
+    } = params;
+
+    if (!user || typeof user !== 'object') {
+      throw new ValidationError('verifyFromApp requires user object');
+    }
+
+    const walletAddress =
+      user.walletAddress ||
+      user.address ||
+      user.identity;
+    if (!walletAddress || typeof walletAddress !== 'string') {
+      throw new ValidationError('verifyFromApp requires user.walletAddress');
+    }
+
+    const delegationQHash =
+      this.config.appLinkQHash ||
+      (typeof process !== 'undefined' && process.env && process.env.NEUS_APP_LINK_QHASH) ||
+      null;
+
+    let data;
+    if (explicitData && typeof explicitData === 'object') {
+      data = { owner: walletAddress, ...explicitData };
+    } else if (content && typeof content === 'object') {
+      data = {
+        owner: walletAddress,
+        content: JSON.stringify(content),
+        contentType: typeof content.contentType === 'string' ? content.contentType : 'application/json',
+        reference: content.reference || { type: 'other' }
+      };
+    } else if (typeof content === 'string') {
+      data = {
+        owner: walletAddress,
+        content,
+        reference: { type: 'other' }
+      };
+    } else {
+      data = { owner: walletAddress, reference: { type: 'other' } };
+    }
+
+    const signedTimestamp = Date.now();
+    const verifierIds = [verifier];
+
+    return this.verify({
+      verifierIds,
+      data,
+      walletAddress,
+      signedTimestamp,
+      ...(delegationQHash ? { delegationQHash } : {}),
+      options
+    });
+  }
+
   async verify(params) {
-    if ((!params?.signature || !params?.walletAddress) && (params?.verifier || params?.content || params?.data)) {
+    if (
+      (isPlaceholderNeusSignature(params?.signature) || !params?.signature || !params?.walletAddress) &&
+      (params?.verifier || params?.content || params?.data)
+    ) {
       const { content, verifier = 'ownership-basic', data = null, wallet = null, options = {} } = params;
 
       if (verifier === 'ownership-basic' && !data && (!content || typeof content !== 'string')) {
@@ -659,7 +757,7 @@ export class NeusClient {
         }
       } else {
         if (typeof window === 'undefined' || !window.ethereum) {
-          throw new ConfigurationError('No Web3 wallet detected. Please install MetaMask or provide wallet parameter.');
+          throw new ConfigurationError('No EVM browser wallet detected. Provide wallet explicitly for non-EVM flows and include chain as a CAIP-2 value.');
         }
         await window.ethereum.request({ method: 'eth_requestAccounts' });
         provider = window.ethereum;
@@ -777,9 +875,13 @@ export class NeusClient {
         verificationData = {
           agentId: data.agentId,
           agentWallet: data?.agentWallet || walletAddress,
+          ...(data?.agentChainRef && { agentChainRef: data.agentChainRef }),
+          ...(data?.agentAccountId && { agentAccountId: data.agentAccountId }),
           ...(data?.agentLabel && { agentLabel: data.agentLabel }),
           ...(data?.agentType && { agentType: data.agentType }),
+          ...(data?.avatar && { avatar: data.avatar }),
           ...(data?.description && { description: data.description }),
+          ...(data?.defaultRuntime && { defaultRuntime: data.defaultRuntime }),
           ...(data?.capabilities && { capabilities: data.capabilities }),
           ...(data?.instructions && { instructions: data.instructions }),
           ...(data?.skills && { skills: data.skills }),
@@ -791,7 +893,11 @@ export class NeusClient {
         }
         verificationData = {
           controllerWallet: data?.controllerWallet || walletAddress,
+          ...(data?.controllerChainRef && { controllerChainRef: data.controllerChainRef }),
           agentWallet: data.agentWallet,
+          ...(data?.agentChainRef && { agentChainRef: data.agentChainRef }),
+          ...(data?.controllerAccountId && { controllerAccountId: data.controllerAccountId }),
+          ...(data?.agentAccountId && { agentAccountId: data.agentAccountId }),
           ...(data?.agentId && { agentId: data.agentId }),
           ...(data?.scope && { scope: data.scope }),
           ...(data?.permissions && { permissions: data.permissions }),
@@ -800,7 +906,13 @@ export class NeusClient {
           ...(data?.receiptDisclosure && { receiptDisclosure: data.receiptDisclosure }),
           ...(data?.expiresAt && { expiresAt: data.expiresAt }),
           ...(data?.instructions && { instructions: data.instructions }),
-          ...(data?.skills && { skills: data.skills })
+          ...(data?.skills && { skills: data.skills }),
+          ...(data?.model && { model: data.model }),
+          ...(data?.provider && { provider: data.provider }),
+          ...(data?.runtimePolicy && { runtimePolicy: data.runtimePolicy }),
+          ...(data?.allowedActions && { allowedActions: data.allowedActions }),
+          ...(data?.deniedActions && { deniedActions: data.deniedActions }),
+          ...(data?.approvalPolicy && { approvalPolicy: data.approvalPolicy })
         };
       } else if (verifier === 'ai-content-moderation') {
         if (!data?.content) {
@@ -962,14 +1074,17 @@ export class NeusClient {
       verifierIds,
       data,
       walletAddress,
-      signature,
+      signature: rawSignature,
       signedTimestamp,
       chainId,
       chain,
       signatureMethod,
+      delegationQHash,
       options = {}
     } = params;
 
+    const signature = isPlaceholderNeusSignature(rawSignature) ? undefined : rawSignature;
+
     const resolvedChainId = chainId || (chain ? null : NEUS_CONSTANTS.HUB_CHAIN_ID);
 
     const normalizeVerifierId = (id) => {
@@ -988,8 +1103,12 @@ export class NeusClient {
     if (!walletAddress || typeof walletAddress !== 'string') {
       throw new ValidationError('walletAddress is required');
     }
-    if (!signature) {
-      throw new ValidationError('signature is required');
+    const hasAppAttribution =
+      typeof this.config.appId === 'string' && this.config.appId.trim().length > 0;
+    if (!signature && !delegationQHash && !hasAppAttribution) {
+      throw new ValidationError(
+        'signature, delegationQHash, or NeusClient config appId (sent as X-Neus-App) is required'
+      );
     }
     if (!signedTimestamp || typeof signedTimestamp !== 'number') {
       throw new ValidationError('signedTimestamp is required');
@@ -1019,11 +1138,12 @@ export class NeusClient {
       verifierIds: normalizedVerifierIds,
       data,
       walletAddress,
-      signature,
+      ...(signature ? { signature } : {}),
       signedTimestamp,
       ...(resolvedChainId !== null && { chainId: resolvedChainId }),
       ...(chain && { chain }),
       ...(signatureMethod && { signatureMethod }),
+      ...(delegationQHash && { delegationQHash }),
       options: optionsPayload
     };
 
@@ -1037,11 +1157,10 @@ export class NeusClient {
   }
 
   async getProof(qHash) {
-    const resolvedQHash = qHash; // Legacy input compatibility only. Do not expose or store proofId.
-    if (!resolvedQHash || typeof resolvedQHash !== 'string') {
+    if (!qHash || typeof qHash !== 'string') {
       throw new ValidationError('qHash is required');
     }
-    const response = await this._makeRequest('GET', `/api/v1/proofs/${resolvedQHash}`);
+    const response = await this._makeRequest('GET', `/api/v1/proofs/${qHash}`);
 
     if (!response.success) {
       throw new ApiError(`Failed to get proof: ${response.error?.message || 'Unknown error'}`, response.error);
@@ -1051,8 +1170,7 @@ export class NeusClient {
   }
 
   async getPrivateProof(qHash, wallet = null) {
-    const resolvedQHash = qHash; // Legacy input compatibility only. Do not expose or store proofId.
-    if (!resolvedQHash || typeof resolvedQHash !== 'string') {
+    if (!qHash || typeof qHash !== 'string') {
       throw new ValidationError('qHash is required');
     }
 
@@ -1070,7 +1188,7 @@ export class NeusClient {
         ...(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 response = await this._makeRequest('GET', `/api/v1/proofs/${resolvedQHash}`, null, headers);
+      const response = await this._makeRequest('GET', `/api/v1/proofs/${qHash}`, null, headers);
       if (!response.success) {
         throw new ApiError(
           `Failed to access private proof: ${response.error?.message || 'Unauthorized'}`,
@@ -1094,7 +1212,7 @@ export class NeusClient {
     const message = constructVerificationMessage({
       walletAddress,
       signedTimestamp,
-      data: { action: 'access_private_proof', qHash: resolvedQHash },
+      data: { action: 'access_private_proof', qHash: qHash },
       verifierIds: ['ownership-basic'],
       ...(signerIsEvm ? { chainId: this._getHubChainId() } : { chain })
     });
@@ -1114,7 +1232,7 @@ export class NeusClient {
       throw new ValidationError(`Failed to sign message: ${error.message}`);
     }
 
-    const response = await this._makeRequest('GET', `/api/v1/proofs/${resolvedQHash}`, null, {
+    const response = await this._makeRequest('GET', `/api/v1/proofs/${qHash}`, null, {
       'x-wallet-address': walletAddress,
       'x-signature': signature,
       'x-signed-timestamp': signedTimestamp.toString(),
@@ -1164,14 +1282,13 @@ export class NeusClient {
   }
 
   async pollProofStatus(qHash, options = {}) {
-    const resolvedQHash = qHash; // Legacy input compatibility only. Do not expose or store proofId.
     const {
       interval = 5000,
       timeout = 120000,
       onProgress
     } = options;
 
-    if (!resolvedQHash || typeof resolvedQHash !== 'string') {
+    if (!qHash || typeof qHash !== 'string') {
       throw new ValidationError('qHash is required');
     }
 
@@ -1180,7 +1297,7 @@ export class NeusClient {
 
     while (Date.now() - startTime < timeout) {
       try {
-        const status = await this.getProof(resolvedQHash);
+        const status = await this.getProof(qHash);
         consecutiveRateLimits = 0;
 
         if (onProgress && typeof onProgress === 'function') {
@@ -1233,8 +1350,7 @@ export class NeusClient {
   }
 
   async revokeOwnProof(qHash, wallet) {
-    const resolvedQHash = qHash; // Legacy input compatibility only. Do not expose or store proofId.
-    if (!resolvedQHash || typeof resolvedQHash !== 'string') {
+    if (!qHash || typeof qHash !== 'string') {
       throw new ValidationError('qHash is required');
     }
     const providerWallet = wallet || this._getDefaultBrowserWallet();
@@ -1250,7 +1366,7 @@ export class NeusClient {
     const message = constructVerificationMessage({
       walletAddress: address,
       signedTimestamp,
-      data: { action: 'revoke_proof', qHash: resolvedQHash },
+      data: { action: 'revoke_proof', qHash: qHash },
       verifierIds: ['ownership-basic'],
       ...(signerIsEvm ? { chainId: this._getHubChainId() } : { chain })
     });
@@ -1270,7 +1386,7 @@ export class NeusClient {
       throw new ValidationError(`Failed to sign revocation: ${error.message}`);
     }
 
-    const res = await this._makeRequest('POST', `/api/v1/proofs/revoke-self/${resolvedQHash}`, {
+    const res = await this._makeRequest('POST', `/api/v1/proofs/revoke-self/${qHash}`, {
       walletAddress: address,
       signature,
       signedTimestamp,
@@ -1765,9 +1881,6 @@ export class NeusClient {
     const qHash = response?.data?.qHash ||
                   response?.qHash ||
                   response?.data?.resource?.qHash ||
-                  response?.data?.proofId || // Legacy input compatibility only. Do not expose or store proofId.
-                  response?.proofId || // Legacy input compatibility only. Do not expose or store proofId.
-                  response?.data?.resource?.proofId || // Legacy input compatibility only. Do not expose or store proofId.
                   response?.data?.id;
 
     const status = response?.data?.status ||

package/errors.js

@@ -79,7 +79,7 @@ export class NetworkError extends SDKError {
     super(message, code);
     this.name = 'NetworkError';
     this.originalError = originalError;
-    this.isRetryable = true; // Network errors are typically retryable
+    this.isRetryable = true; // Network errors are retryable
   }
 
   static isNetworkError(error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@neus/sdk",
-  "version": "1.0.10",
-  "description": "Issue and check NEUS trust receipts across apps, agents, gates, payments, and workflows.",
+  "version": "1.1.0",
+  "description": "NEUS makes trust portable across the internet — so people, apps, and AI agents can prove what is real before access, payout, or execution.",
   "bin": {
     "neus": "cli/neus.mjs"
   },
@@ -67,7 +67,10 @@
     "universal-protocol",
     "proof",
     "ownership",
-    "sdk"
+    "sdk",
+    "mcp",
+    "model-context-protocol",
+    "oauth"
   ],
   "author": "NEUS Network",
   "license": "Apache-2.0",
@@ -80,6 +83,10 @@
     "url": "https://github.com/neus/network/issues"
   },
   "homepage": "https://neus.network",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
   "engines": {
     "node": ">=20.0.0"
   },
@@ -124,6 +131,7 @@
     "widgets.cjs",
     "types.d.ts",
     "README.md",
+    "CHANGELOG.md",
     "SECURITY.md",
     "LICENSE",
     "neus-logo.svg",

package/types.d.ts

@@ -7,7 +7,9 @@ declare module '@neus/sdk' {
 
   export class NeusClient {
     constructor(config?: NeusClientConfig);
-    
+
+    verifyFromApp(params: VerifyFromAppParams): Promise<VerificationResult>;
+
     verify(params: VerifyParams): Promise<VerificationResult>;
     
     getProof(qHash: string): Promise<StatusResult>;
@@ -57,6 +59,8 @@ declare module '@neus/sdk' {
     apiUrl?: string;
     apiKey?: string;
     appId?: string;
+    /** Optional: only when using legacy `delegationQHash` on verify requests. App-linked servers rely on `appId` + Origin + stored delegation. */
+    appLinkQHash?: string;
     paymentSignature?: string;
     extraHeaders?: Record<string, string>;
     timeout?: number;
@@ -77,8 +81,12 @@ declare module '@neus/sdk' {
   export interface VerifierCatalogMetadataEntry {
     category?: string;
     description?: string;
+    accessLevel?: 'public' | 'pro' | 'custom' | 'admin' | string;
     flowType?: 'instant' | 'interactive' | 'external_lookup' | string;
     expiryType?: 'permanent' | 'point_in_time' | 'expiring' | string;
+    allowsDelegatedSubject?: boolean;
+    compatibleWith?: string[];
+    conflictsWith?: string[];
     supportsDirectApi?: boolean;
     supportsHostedVerify?: boolean;
     dataSchema?: Record<string, any>;
@@ -92,6 +100,18 @@ declare module '@neus/sdk' {
     meta?: Record<string, any>;
   }
   
+  export interface VerifyFromAppParams {
+    user: {
+      walletAddress?: string;
+      address?: string;
+      identity?: string;
+    };
+    verifier?: VerifierId;
+    content?: string | Record<string, any>;
+    data?: VerificationData;
+    options?: VerifyOptions;
+  }
+
   export interface VerifyParams {
     verifier?: VerifierId;
     content?: string;
@@ -105,6 +125,7 @@ declare module '@neus/sdk' {
     chainId?: number;
     chain?: string;
     signatureMethod?: string;
+    delegationQHash?: string;
     wallet?: WalletLike;
   }
     
@@ -582,6 +603,8 @@ declare module '@neus/sdk' {
         | 'doc'
         | 'media'
         | 'username-claim'
+        | 'job'
+        | 'job-status'
         | 'other';
       id?: string;
       title?: string;
@@ -629,7 +652,8 @@ declare module '@neus/sdk' {
     contractAddress: string;
     tokenId: string;
     tokenType?: 'erc721' | 'erc1155';
-    chainId: number;
+    chainId?: number;
+    chain?: string;
     blockNumber?: number;
     [key: string]: any;
   };
@@ -638,24 +662,29 @@ declare module '@neus/sdk' {
     ownerAddress?: string;
     contractAddress: string;
     minBalance: string;
-    chainId: number;
+    chainId?: number;
+    chain?: string;
     blockNumber?: number;
     [key: string]: any;
   };
 
   type WalletRiskData = {
+    walletAddress: string;
     provider?: string;
-    walletAddress?: string;
     chainId?: number;
-    includeDetails?: boolean;
+    chain?: string;
     [key: string]: any;
   };
 
   type WalletLinkData = {
-    primaryWalletAddress: string;
-    secondaryWalletAddress: string;
+    primaryWalletAddress?: string;
+    secondaryWalletAddress?: string;
+    primaryAccountId?: string;
+    secondaryAccountId?: string;
+    primaryChainRef?: string;
+    secondaryChainRef?: string;
     signature: string;
-    chain: string;
+    chain?: string;
     signatureMethod: string;
     signedTimestamp: number;
     relationshipType?: 'primary' | 'personal' | 'org' | 'affiliate' | 'agent' | 'linked';
@@ -679,36 +708,70 @@ declare module '@neus/sdk' {
     [key: string]: any;
   };
 
+  type AgentSkillRef = {
+    id: string;
+    label?: string;
+    version?: string;
+    provider?: string;
+    kind?: 'native' | 'integration' | 'plugin' | 'mcp' | 'toolkit';
+    configId?: string;
+    enabled?: boolean;
+  };
+
   type AgentIdentityData = {
     agentId: string;
     agentWallet: string;
+    agentChainRef: string;
+    agentAccountId?: string;
     agentLabel?: string;
     agentType?: 'ai' | 'bot' | 'service' | 'automation' | 'agent';
+    avatar?: string;
     description?: string;
-    capabilities?: any[];
+    defaultRuntime?: {
+      provider?: string;
+      model?: string;
+      mode?: string;
+    };
+    capabilities?: Record<string, boolean>;
     instructions?: string;
-    skills?: string[];
+    skills?: AgentSkillRef[];
     services?: Array<{
       name: string;
       endpoint: string;
       version?: string;
     }>;
-    [key: string]: any;
   };
 
   type AgentDelegationData = {
     controllerWallet: string;
+    controllerChainRef: string;
     agentWallet: string;
+    agentChainRef: string;
+    controllerAccountId?: string;
+    agentAccountId?: string;
     agentId?: string;
     scope?: string;
-    permissions?: any[];
+    permissions?: string[];
     maxSpend?: string;
     allowedPaymentTypes?: string[];
     receiptDisclosure?: 'none' | 'summary' | 'full';
     expiresAt?: number;
     instructions?: string;
-    skills?: string[];
-    [key: string]: any;
+    skills?: AgentSkillRef[];
+    model?: string;
+    provider?: string;
+    runtimePolicy?: {
+      allowedProviders?: string[];
+      allowedModelClasses?: string[];
+      requiresHumanApproval?: boolean;
+      secretsExposedToReceipt?: boolean;
+    };
+    allowedActions?: string[];
+    deniedActions?: string[];
+    approvalPolicy?: {
+      humanApprovalRequiredForNewClaims?: boolean;
+      preApprovedContentOnly?: boolean;
+    };
   };
 
   type CoreVerificationData =
@@ -768,6 +831,8 @@ declare module '@neus/sdk' {
         | 'doc'
         | 'media'
         | 'username-claim'
+        | 'job'
+        | 'job-status'
         | 'other';
       id?: string;
       title?: string;

package/widgets/README.md

@@ -10,7 +10,7 @@ npm install @neus/sdk react react-dom
 
 ## VerifyGate
 
-Create mode defaults to **private**. Override `proofOptions` only when you intentionally need public visibility for link-based or public checks.
+Create mode defaults to **private**. Override `proofOptions` only when you need public visibility for link-based or public checks.
 
 ```jsx
 import { VerifyGate } from '@neus/sdk/widgets';

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

@@ -28,7 +28,7 @@ var NeusLogo = ({ size = 12, logoUrl }) => /* @__PURE__ */ jsx(
   }
 );
 function ProofBadge({
-  qHash: qHashProp,
+  qHash,
   proofUrlPattern = "/proof/:qHash",
   size = "sm",
   uiLinkBase = "https://neus.network",
@@ -38,10 +38,8 @@ function ProofBadge({
   showLabel = true,
   logoUrl = void 0,
   onClick = void 0,
-  className = "",
-  ...legacyProps
+  className = ""
 }) {
-  const qHash = qHashProp ?? legacyProps.proofId;
   const resolvedQHash = qHash;
   const [status, setStatus] = useState(() => {
     if (proof) {
@@ -149,7 +147,7 @@ function ProofBadge({
   );
 }
 function SimpleProofBadge({
-  qHash: qHashProp,
+  qHash,
   proofUrlPattern = "/proof/:qHash",
   uiLinkBase = "https://neus.network",
   apiUrl = DEFAULT_API_BASE,
@@ -158,10 +156,8 @@ function SimpleProofBadge({
   logoUrl = void 0,
   proof = void 0,
   onClick = void 0,
-  className = "",
-  ...legacyProps
+  className = ""
 }) {
-  const qHash = qHashProp ?? legacyProps.proofId;
   const resolvedQHash = qHash;
   const [status, setStatus] = useState(() => {
     if (proof) {
@@ -244,17 +240,15 @@ function SimpleProofBadge({
   );
 }
 function NeusPillLink({
-  qHash: qHashProp,
+  qHash,
   proofUrlPattern = "/proof/:qHash",
   uiLinkBase = "https://neus.network",
   label = "View",
   size = "sm",
   logoUrl = void 0,
   onClick = void 0,
-  className = "",
-  ...legacyProps
+  className = ""
 }) {
-  const qHash = qHashProp ?? legacyProps.proofId;
   const resolvedQHash = qHash;
   const base = String(uiLinkBase).replace(/\/$/, "");
   const href = resolvedQHash ? `${base}${String(proofUrlPattern).replace(":qHash", resolvedQHash)}` : base;
@@ -304,17 +298,15 @@ function NeusPillLink({
   );
 }
 function VerifiedIcon({
-  qHash: qHashProp,
+  qHash,
   proofUrlPattern = "/proof/:qHash",
   uiLinkBase = "https://neus.network",
   size = 14,
   logoUrl = void 0,
   tooltip = "Proof",
   onClick = void 0,
-  className = "",
-  ...legacyProps
+  className = ""
 }) {
-  const qHash = qHashProp ?? legacyProps.proofId;
   const resolvedQHash = qHash;
   const href = resolvedQHash ? `${String(uiLinkBase).replace(/\/$/, "")}${String(proofUrlPattern).replace(":qHash", resolvedQHash)}` : void 0;
   const handleClick = (e) => {