@neus/sdk 1.0.12 → 1.1.1

package/client.js

@@ -1,4 +1,5 @@
 import { ApiError, ValidationError, NetworkError, ConfigurationError } from './errors.js';
+import { fetchSponsorGrant } from './sponsor.js';
 import {
   PORTABLE_PROOF_SIGNER_HEADER,
   constructVerificationMessage,
@@ -239,6 +240,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)) {
@@ -253,6 +265,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') {
@@ -373,6 +397,77 @@ export class NeusClient {
     } catch {
       void 0;
     }
+
+    /** @type {{ token: string, expMs: number, key: string } | null} */
+    this._sponsorGrantCache = null;
+  }
+
+  _getBillingWallet() {
+    const raw =
+      this.config.billingWallet ||
+      this.config.sponsorOrgWallet ||
+      this.config.orgWallet ||
+      null;
+    if (typeof raw !== 'string') return null;
+    const trimmed = raw.trim().toLowerCase();
+    return /^0x[a-f0-9]{40}$/.test(trimmed) ? trimmed : null;
+  }
+
+  _resolveIntegratorOrigin() {
+    if (typeof this.config.appOrigin === 'string' && this.config.appOrigin.trim()) {
+      return this.config.appOrigin.trim();
+    }
+    try {
+      if (typeof window !== 'undefined' && window.location?.origin) {
+        return window.location.origin;
+      }
+    } catch {
+      void 0;
+    }
+    return null;
+  }
+
+  async _resolveSponsorGrantHeaders(verifierIds = []) {
+    const appId = typeof this.config.appId === 'string' ? this.config.appId.trim() : '';
+    const orgWallet = this._getBillingWallet();
+    if (!appId || !orgWallet) {
+      return {};
+    }
+
+    const normalizedVerifierIds = Array.isArray(verifierIds)
+      ? verifierIds.map((v) => String(v || '').trim()).filter(Boolean).slice(0, 25)
+      : [];
+    const cacheKey = `${appId}:${orgWallet}:${normalizedVerifierIds.join(',')}`;
+    const now = Date.now();
+    if (
+      this._sponsorGrantCache &&
+      this._sponsorGrantCache.key === cacheKey &&
+      this._sponsorGrantCache.expMs > now + 30_000
+    ) {
+      return { 'X-Sponsor-Grant': this._sponsorGrantCache.token };
+    }
+
+    const origin = this._resolveIntegratorOrigin();
+    const grant = await fetchSponsorGrant({
+      apiUrl: this.baseUrl,
+      appId,
+      orgWallet,
+      verifierIds: normalizedVerifierIds,
+      origin
+    });
+
+    const expSeconds = Number(grant?.exp);
+    const expMs = Number.isFinite(expSeconds) && expSeconds > 0
+      ? expSeconds * 1000
+      : now + 15 * 60 * 1000;
+
+    this._sponsorGrantCache = {
+      key: cacheKey,
+      token: grant.sponsorGrant,
+      expMs
+    };
+
+    return { 'X-Sponsor-Grant': grant.sponsorGrant };
   }
 
   _getHubChainId() {
@@ -457,12 +552,12 @@ export class NeusClient {
     throw new ConfigurationError('Invalid wallet provider');
   }
 
-  _getDefaultBrowserWallet() {
-    if (typeof window === 'undefined') return 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;
-  }
+  _getDefaultBrowserWallet() {
+    if (typeof window === 'undefined') return 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 } = {}) {
     const providerWallet = wallet || this._getDefaultBrowserWallet();
@@ -732,10 +827,10 @@ export class NeusClient {
             walletAddress = Array.isArray(accounts) && accounts.length > 0 ? accounts[0] : null;
           }
         }
-      } else {
-        if (typeof window === 'undefined' || !window.ethereum) {
-          throw new ConfigurationError('No EVM browser wallet detected. Provide wallet explicitly for non-EVM flows and include chain as a CAIP-2 value.');
-        }
+      } else {
+        if (typeof window === 'undefined' || !window.ethereum) {
+          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;
         const accounts = await provider.request({ method: 'eth_accounts' });
@@ -852,9 +947,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 }),
@@ -866,7 +965,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 }),
@@ -875,7 +978,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) {
@@ -1110,7 +1219,8 @@ export class NeusClient {
       options: optionsPayload
     };
 
-    const response = await this._makeRequest('POST', '/api/v1/verification', requestData);
+    const sponsorHeaders = await this._resolveSponsorGrantHeaders(normalizedVerifierIds);
+    const response = await this._makeRequest('POST', '/api/v1/verification', requestData, sponsorHeaders);
 
     if (!response.success) {
       throw new ApiError(`Verification failed: ${response.error?.message || 'Unknown error'}`, response.error);
@@ -1120,11 +1230,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);
@@ -1134,8 +1243,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');
     }
 
@@ -1153,7 +1261,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'}`,
@@ -1177,7 +1285,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 })
     });
@@ -1197,7 +1305,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(),
@@ -1247,14 +1355,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');
     }
 
@@ -1263,7 +1370,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') {
@@ -1316,8 +1423,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();
@@ -1333,7 +1439,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 })
     });
@@ -1353,7 +1459,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,
@@ -1586,7 +1692,23 @@ export class NeusClient {
       }
     }
 
-    const response = await this._makeRequest('GET', `/api/v1/proofs/check?${qs.toString()}`, null, headersOverride);
+    let mergedHeaders = headersOverride;
+    if (!mergedHeaders) {
+      try {
+        const sponsorHeaders = await this._resolveSponsorGrantHeaders(
+          Array.isArray(params.verifierIds)
+            ? params.verifierIds
+            : (params.verifierIds ? [params.verifierIds] : [])
+        );
+        if (sponsorHeaders && Object.keys(sponsorHeaders).length > 0) {
+          mergedHeaders = sponsorHeaders;
+        }
+      } catch (error) {
+        this._log('Sponsor grant unavailable for gateCheck (continuing without)', error?.message || String(error));
+      }
+    }
+
+    const response = await this._makeRequest('GET', `/api/v1/proofs/check?${qs.toString()}`, null, mergedHeaders);
     if (!response.success) {
       throw new ApiError(`Gate check failed: ${response.error?.message || 'Unknown error'}`, response.error);
     }
@@ -1848,9 +1970,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

@@ -1,189 +1,154 @@
-export class SDKError extends Error {
-  constructor(message, code = 'SDK_ERROR', details = {}) {
-    super(message);
-    this.name = 'SDKError';
-    this.code = code;
-    this.details = details;
-    this.timestamp = Date.now();
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, SDKError);
-    }
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      details: this.details,
-      timestamp: this.timestamp
-    };
-  }
-}
-
-export class ApiError extends SDKError {
-  constructor(message, statusCode = 500, code = 'API_ERROR', response = null) {
-    super(message, code);
-    this.name = 'ApiError';
-    this.statusCode = statusCode;
-    this.response = response;
-
-    this.isClientError = statusCode >= 400 && statusCode < 500;
-    this.isServerError = statusCode >= 500;
-    this.isRetryable = this.isServerError || statusCode === 429; // Server errors or rate limit
-  }
-
-  static fromResponse(response, responseData) {
-    const statusCode = response.status;
-    const message = responseData?.error?.message ||
-                   responseData?.message ||
-                   `API request failed with status ${statusCode}`;
-    const code = responseData?.error?.code || 'API_ERROR';
-
-    return new ApiError(message, statusCode, code, responseData);
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      statusCode: this.statusCode,
-      isClientError: this.isClientError,
-      isServerError: this.isServerError,
-      isRetryable: this.isRetryable
-    };
-  }
-}
-
-export class ValidationError extends SDKError {
-  constructor(message, field = null, value = null) {
-    super(message, 'VALIDATION_ERROR');
-    this.name = 'ValidationError';
-    this.field = field;
-    this.value = value;
-    this.isRetryable = false; // Validation errors are not retryable
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      field: this.field,
-      value: this.value,
-      isRetryable: this.isRetryable
-    };
-  }
-}
-
-export class NetworkError extends SDKError {
-  constructor(message, code = 'NETWORK_ERROR', originalError = null) {
-    super(message, code);
-    this.name = 'NetworkError';
-    this.originalError = originalError;
-    this.isRetryable = true; // Network errors are retryable
-  }
-
-  static isNetworkError(error) {
-    return error instanceof NetworkError ||
-           error.name === 'TypeError' && error.message.includes('fetch') ||
-           error.name === 'AbortError' ||
-           error.code === 'ENOTFOUND' ||
-           error.code === 'ECONNREFUSED' ||
-           error.code === 'ETIMEDOUT';
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      isRetryable: this.isRetryable,
-      originalError: this.originalError ? {
-        name: this.originalError.name,
-        message: this.originalError.message,
-        code: this.originalError.code
-      } : null
-    };
-  }
-}
-
-export class ConfigurationError extends SDKError {
-  constructor(message, configKey = null) {
-    super(message, 'CONFIGURATION_ERROR');
-    this.name = 'ConfigurationError';
-    this.configKey = configKey;
-    this.isRetryable = false; // Config errors require user intervention
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      configKey: this.configKey,
-      isRetryable: this.isRetryable
-    };
-  }
-}
-
-export class VerificationError extends SDKError {
-  constructor(message, verifierId = null, code = 'VERIFICATION_ERROR') {
-    super(message, code);
-    this.name = 'VerificationError';
-    this.verifierId = verifierId;
-    this.isRetryable = true; // Some verification errors might be retryable
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      verifierId: this.verifierId,
-      isRetryable: this.isRetryable
-    };
-  }
-}
-
-export class AuthenticationError extends SDKError {
-  constructor(message, code = 'AUTHENTICATION_ERROR') {
-    super(message, code);
-    this.name = 'AuthenticationError';
-    this.isRetryable = false; // Auth errors require user intervention
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      isRetryable: this.isRetryable
-    };
-  }
-}
-
-export function createErrorFromGeneric(error, context = {}) {
-  if (error instanceof SDKError) {
-    return error;
-  }
-
-  if (NetworkError.isNetworkError(error)) {
-    return new NetworkError(
-      error.message || 'Network error occurred',
-      error.code || 'NETWORK_ERROR',
-      error
-    );
-  }
-
-  if (error.name === 'AbortError' || error.message.includes('timeout')) {
-    return new NetworkError('Request timeout', 'TIMEOUT', error);
-  }
-
-  return new SDKError(
-    error.message || 'Unknown error occurred',
-    error.code || 'UNKNOWN_ERROR',
-    { originalError: error, context }
-  );
-}
-
-export default {
-  SDKError,
-  ApiError,
-  ValidationError,
-  NetworkError,
-  ConfigurationError,
-  VerificationError,
-  AuthenticationError,
-  createErrorFromGeneric
-};
+export class SDKError extends Error {
+  constructor(message, code = 'SDK_ERROR', details = {}) {
+    super(message);
+    this.name = 'SDKError';
+    this.code = code;
+    this.details = details;
+    this.timestamp = Date.now();
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, SDKError);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      timestamp: this.timestamp
+    };
+  }
+}
+
+export class ApiError extends SDKError {
+  constructor(message, statusCode = 500, code = 'API_ERROR', response = null) {
+    super(message, code);
+    this.name = 'ApiError';
+    this.statusCode = statusCode;
+    this.response = response;
+
+    this.isClientError = statusCode >= 400 && statusCode < 500;
+    this.isServerError = statusCode >= 500;
+    this.isRetryable = this.isServerError || statusCode === 429; // Server errors or rate limit
+  }
+
+  static fromResponse(response, responseData) {
+    const statusCode = response.status;
+    const message = responseData?.error?.message ||
+                   responseData?.message ||
+                   `API request failed with status ${statusCode}`;
+    const code = responseData?.error?.code || 'API_ERROR';
+
+    return new ApiError(message, statusCode, code, responseData);
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode,
+      isClientError: this.isClientError,
+      isServerError: this.isServerError,
+      isRetryable: this.isRetryable
+    };
+  }
+}
+
+export class ValidationError extends SDKError {
+  constructor(message, field = null, value = null) {
+    super(message, 'VALIDATION_ERROR');
+    this.name = 'ValidationError';
+    this.field = field;
+    this.value = value;
+    this.isRetryable = false; // Validation errors are not retryable
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      field: this.field,
+      value: this.value,
+      isRetryable: this.isRetryable
+    };
+  }
+}
+
+export class NetworkError extends SDKError {
+  constructor(message, code = 'NETWORK_ERROR', originalError = null) {
+    super(message, code);
+    this.name = 'NetworkError';
+    this.originalError = originalError;
+    this.isRetryable = true; // Network errors are retryable
+  }
+
+  static isNetworkError(error) {
+    return error instanceof NetworkError ||
+           error.name === 'TypeError' && error.message.includes('fetch') ||
+           error.name === 'AbortError' ||
+           error.code === 'ENOTFOUND' ||
+           error.code === 'ECONNREFUSED' ||
+           error.code === 'ETIMEDOUT';
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      isRetryable: this.isRetryable,
+      originalError: this.originalError ? {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        code: this.originalError.code
+      } : null
+    };
+  }
+}
+
+export class ConfigurationError extends SDKError {
+  constructor(message, configKey = null) {
+    super(message, 'CONFIGURATION_ERROR');
+    this.name = 'ConfigurationError';
+    this.configKey = configKey;
+    this.isRetryable = false; // Config errors require user intervention
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      configKey: this.configKey,
+      isRetryable: this.isRetryable
+    };
+  }
+}
+
+export class VerificationError extends SDKError {
+  constructor(message, verifierId = null, code = 'VERIFICATION_ERROR') {
+    super(message, code);
+    this.name = 'VerificationError';
+    this.verifierId = verifierId;
+    this.isRetryable = true; // Some verification errors might be retryable
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      verifierId: this.verifierId,
+      isRetryable: this.isRetryable
+    };
+  }
+}
+
+export class AuthenticationError extends SDKError {
+  constructor(message, code = 'AUTHENTICATION_ERROR') {
+    super(message, code);
+    this.name = 'AuthenticationError';
+    this.isRetryable = false; // Auth errors require user intervention
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      isRetryable: this.isRetryable
+    };
+  }
+}