@fenelabs/fene-sdk 0.3.2 → 0.3.6

package/dist/index.mjs

@@ -1,1083 +1,398 @@
 // src/errors.ts
-var ResonanceAPIError = class extends Error {
-  constructor(statusCode, code, message) {
+var ErrorCode = {
+  // Validator errors
+  VALIDATOR_NOT_FOUND: "VALIDATOR_NOT_FOUND",
+  VALIDATOR_INACTIVE: "VALIDATOR_INACTIVE",
+  // Delegator errors
+  DELEGATOR_NOT_FOUND: "DELEGATOR_NOT_FOUND",
+  NOT_WHITELISTED: "NOT_WHITELISTED",
+  // Referral errors
+  REFERRAL_KEY_INVALID: "REFERRAL_KEY_INVALID",
+  REFERRAL_KEY_EXPIRED: "REFERRAL_KEY_EXPIRED",
+  REFERRAL_KEY_USED: "REFERRAL_KEY_USED",
+  // Auth errors
+  INVALID_SIGNATURE: "INVALID_SIGNATURE",
+  NONCE_EXPIRED: "NONCE_EXPIRED",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  // Service errors (graceful degradation)
+  RPC_UNAVAILABLE: "RPC_UNAVAILABLE",
+  CACHE_UNAVAILABLE: "CACHE_UNAVAILABLE",
+  DATABASE_UNAVAILABLE: "DATABASE_UNAVAILABLE",
+  // General errors
+  BAD_REQUEST: "BAD_REQUEST",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  RATE_LIMITED: "RATE_LIMITED",
+  TIMEOUT: "TIMEOUT",
+  NETWORK_ERROR: "NETWORK_ERROR"
+};
+var ResonanceError = class _ResonanceError extends Error {
+  constructor(code, message, details, statusCode) {
     super(message);
-    this.statusCode = statusCode;
+    this.name = "ResonanceError";
     this.code = code;
-    this.name = "ResonanceAPIError";
-  }
-};
-
-// src/client.ts
-var HTTPClient = class {
-  constructor(config) {
-    this.baseUrl = config.apiUrl.replace(/\/$/, "");
-    this.timeout = config.timeout || 3e4;
-    this.headers = {
-      "Content-Type": "application/json",
-      ...config.headers
-    };
-  }
-  /**
-   * Build URL with query parameters
-   */
-  buildUrl(path, params) {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== void 0 && value !== null) {
-          url.searchParams.append(key, String(value));
-        }
-      });
+    this.details = details;
+    this.statusCode = statusCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ResonanceError);
     }
-    return url.toString();
   }
   /**
-   * Set authorization token
+   * Check if this is a specific error code
    */
-  setAuthToken(token) {
-    if (token) {
-      this.headers["Authorization"] = `Bearer ${token}`;
-    } else {
-      delete this.headers["Authorization"];
-    }
+  is(code) {
+    return this.code === code;
   }
   /**
-   * Set custom header
+   * Convert to JSON representation
    */
-  setHeader(key, value) {
-    this.headers[key] = value;
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
   }
-  /**
-   * Make HTTP GET request
-   */
-  async get(path, params) {
-    const url = this.buildUrl(path, params);
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: this.headers,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        await this.handleError(response);
-      }
-      const json = await response.json();
-      return json.data !== void 0 ? json.data : json;
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timeout after ${this.timeout}ms`);
+};
+function isResonanceError(error) {
+  return error instanceof ResonanceError;
+}
+function hasErrorCode(error, code) {
+  return isResonanceError(error) && error.is(code);
+}
+function isNetworkError(error) {
+  if (isResonanceError(error)) {
+    return error.is(ErrorCode.RPC_UNAVAILABLE) || error.is(ErrorCode.CACHE_UNAVAILABLE) || error.is(ErrorCode.DATABASE_UNAVAILABLE);
+  }
+  return false;
+}
+function isAuthError(error) {
+  if (isResonanceError(error)) {
+    return error.is(ErrorCode.UNAUTHORIZED) || error.is(ErrorCode.INVALID_SIGNATURE) || error.is(ErrorCode.NONCE_EXPIRED);
+  }
+  return false;
+}
+function isNotFoundError(error) {
+  if (isResonanceError(error)) {
+    return error.is(ErrorCode.VALIDATOR_NOT_FOUND) || error.is(ErrorCode.DELEGATOR_NOT_FOUND);
+  }
+  return false;
+}
+
+// src/client.ts
+var DEFAULT_CONFIG = {
+  timeout: 3e4,
+  retries: 2,
+  retryDelay: 1e3
+};
+function validateConfig(config) {
+  if (config.timeout !== void 0 && (config.timeout < 0 || config.timeout > 3e5)) {
+    throw new Error("timeout must be between 0 and 300000ms (5 minutes)");
+  }
+  if (config.retries !== void 0 && (config.retries < 0 || config.retries > 5)) {
+    throw new Error("retries must be between 0 and 5");
+  }
+  if (config.retryDelay !== void 0 && (config.retryDelay < 0 || config.retryDelay > 1e4)) {
+    throw new Error("retryDelay must be between 0 and 10000ms");
+  }
+  if (config.baseUrl && !config.baseUrl.match(/^https?:\/\//)) {
+    throw new Error("baseUrl must start with http:// or https://");
+  }
+}
+var ENV_API_URL = "RESONANCE_API_URL";
+var ENV_API_TOKEN = "RESONANCE_API_TOKEN";
+function getEnv(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  if (typeof import.meta !== "undefined" && import.meta.env) {
+    return import.meta.env[`VITE_${key}`] || import.meta.env[`NEXT_PUBLIC_${key}`];
+  }
+  return void 0;
+}
+var ResonanceClient = class {
+  constructor(config = {}) {
+    validateConfig(config);
+    const defaultUrl = "http://localhost:8080";
+    const envUrl = getEnv(ENV_API_URL);
+    const baseUrl = config.baseUrl || envUrl || defaultUrl;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = config.token || getEnv(ENV_API_TOKEN);
+    this.timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+    this.retries = config.retries ?? DEFAULT_CONFIG.retries;
+    this.retryDelay = config.retryDelay ?? DEFAULT_CONFIG.retryDelay;
+    this.onTokenExpired = config.onTokenExpired;
+    this.onRequest = config.onRequest;
+    this.onResponse = config.onResponse;
+    this.onError = config.onError;
+  }
+  // ============================================
+  // Helper Methods
+  // ============================================
+  setToken(token) {
+    this.token = token;
+  }
+  clearToken() {
+    this.token = void 0;
+  }
+  async request(path, options = {}) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        return await this.executeRequest(path, options, attempt);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof ResonanceError) {
+          if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+            throw error;
+          }
+        }
+        if (attempt >= this.retries) {
+          throw error;
+        }
+        const delay = this.retryDelay * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
-      throw error;
     }
+    throw lastError || new Error("Request failed");
   }
-  /**
-   * Make HTTP POST request
-   */
-  async post(path, body) {
-    const url = this.buildUrl(path);
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+  async executeRequest(path, options, attemptNumber) {
+    const startTime = Date.now();
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const requestContext = {
+      method: options.method || "GET",
+      url,
+      headers,
+      body: options.body,
+      timestamp: startTime,
+      attemptNumber
+    };
     try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: this.headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        await this.handleError(response);
-      }
-      const json = await response.json();
-      return json.data !== void 0 ? json.data : json;
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timeout after ${this.timeout}ms`);
-      }
-      throw error;
+      this.onRequest?.(requestContext);
+    } catch (hookError) {
+      console.error("onRequest hook error:", hookError);
     }
-  }
-  /**
-   * Make HTTP DELETE request
-   */
-  async delete(path) {
-    const url = this.buildUrl(path);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
       const response = await fetch(url, {
-        method: "DELETE",
-        headers: this.headers,
+        ...options,
+        headers,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
+      const duration = Date.now() - startTime;
+      if (response.status === 401) {
+        this.onTokenExpired?.();
+      }
       if (!response.ok) {
-        await this.handleError(response);
+        const error = await response.json().catch(() => null);
+        const resonanceError = error && typeof error === "object" && "code" in error && "message" in error ? new ResonanceError(
+          error.code,
+          error.message,
+          error.details,
+          response.status
+        ) : new ResonanceError(
+          "INTERNAL_ERROR",
+          error?.error || `HTTP ${response.status}`,
+          void 0,
+          response.status
+        );
+        try {
+          this.onError?.(resonanceError, requestContext);
+        } catch (hookError) {
+          console.error("onError hook error:", hookError);
+        }
+        throw resonanceError;
       }
-      const json = await response.json();
-      return json.data !== void 0 ? json.data : json;
+      const data = await response.json();
+      const responseContext = {
+        ...requestContext,
+        status: response.status,
+        statusText: response.statusText,
+        duration,
+        data
+      };
+      try {
+        this.onResponse?.(responseContext);
+      } catch (hookError) {
+        console.error("onResponse hook error:", hookError);
+      }
+      return data;
     } catch (error) {
+      clearTimeout(timeoutId);
       if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timeout after ${this.timeout}ms`);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Handle HTTP errors
-   */
-  async handleError(response) {
-    let errorCode = "UNKNOWN_ERROR";
-    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-    try {
-      const errorData = await response.json();
-      if (errorData.error) {
-        errorCode = errorData.error.code;
-        errorMessage = errorData.error.message;
+        const timeoutError = new ResonanceError(
+          "TIMEOUT",
+          `Request timed out after ${this.timeout}ms`,
+          { url, timeout: this.timeout },
+          408
+        );
+        try {
+          this.onError?.(timeoutError, requestContext);
+        } catch (hookError) {
+          console.error("onError hook error:", hookError);
+        }
+        throw timeoutError;
       }
-    } catch {
-    }
-    throw new ResonanceAPIError(response.status, errorCode, errorMessage);
-  }
-  /*
-  * Automatic Retry transient errors network
-  */
-  async fetchWithRetry(url, options, retries = 3) {
-    for (let i = 0; i < retries; i++) {
-      try {
-        return await fetch(url, options);
-      } catch (error) {
-        if (i === retries - 1) throw error;
-        await new Promise((resolve) => setTimeout(resolve, 1e3 * (i + 1)));
+      if (error instanceof Error) {
+        const networkError = error instanceof ResonanceError ? error : new ResonanceError("NETWORK_ERROR", error.message, void 0, 0);
+        try {
+          this.onError?.(networkError, requestContext);
+        } catch (hookError) {
+          console.error("onError hook error:", hookError);
+        }
+        throw networkError;
       }
+      throw error;
     }
-    throw new Error("Max retries reached");
-  }
-};
-
-// src/auth.ts
-var AuthService = class {
-  constructor(apiUrl) {
-    this.tokenKey = "resonance_jwt_token";
-    this.apiUrl = apiUrl;
   }
-  /**
-   * Get nonce for wallet authentication
-   * POST /eth/v1/auth/nonce
-   */
+  // ============================================
+  // Auth
+  // ============================================
   async getNonce(address) {
-    const response = await fetch(`${this.apiUrl}/eth/v1/auth/nonce`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ address })
-    });
-    if (!response.ok) {
-      throw new Error("Failed to get nonce");
-    }
-    const result = await response.json();
-    return result.data;
-  }
-  /**
-   * Verify wallet signature and get JWT token
-   * POST /eth/v1/auth/verify
-   */
-  async verify(params) {
-    const response = await fetch(`${this.apiUrl}/eth/v1/auth/verify`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(params)
-    });
-    if (!response.ok) {
-      throw new Error("Authentication failed");
-    }
-    const result = await response.json();
-    const token = result.data.token;
-    if (typeof window !== "undefined") {
-      sessionStorage.setItem(this.tokenKey, token);
-    }
-    return { token };
+    return this.request(`/eth/v1/auth/nonce?address=${address}`);
   }
-  /**
-   * Connect wallet and authenticate
-   */
-  async connectWallet(provider, role = "delegator") {
-    const signer = await provider.getSigner();
-    const address = await signer.getAddress();
-    const timestamp = Math.floor(Date.now() / 1e3);
-    const nonce = Math.floor(Math.random() * 1e6);
-    const message = `Sign this message to login to Resonance Dashboard
-
-Address: ${address}
-Role: ${role}
-Nonce: ${nonce}
-Timestamp: ${timestamp}
-
-This will not trigger any blockchain transaction or cost gas fees.`;
-    const signature = await signer.signMessage(message);
-    const response = await fetch(`${this.apiUrl}/auth/login`, {
+  async verify(address, signature) {
+    const result = await this.request("/eth/v1/auth/verify", {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        address,
-        message,
-        signature,
-        role,
-        timestamp,
-        nonce
-      })
+      body: JSON.stringify({ address, signature })
     });
-    if (!response.ok) {
-      throw new Error("Authentication failed");
-    }
-    const data = await response.json();
-    if (typeof window !== "undefined") {
-      sessionStorage.setItem(this.tokenKey, data.token);
-    }
-    return data;
-  }
-  /**
-   * Get stored JWT token
-   */
-  getToken() {
-    if (typeof window === "undefined") return null;
-    return sessionStorage.getItem(this.tokenKey);
-  }
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated() {
-    const token = this.getToken();
-    if (!token) return false;
-    try {
-      const claims = this.parseToken(token);
-      return claims.exp * 1e3 > Date.now();
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Parse JWT token to get claims
-   */
-  parseToken(token) {
-    const payload = token.split(".")[1];
-    const decoded = atob(payload);
-    return JSON.parse(decoded);
-  }
-  /**
-   * Get user info from token
-   */
-  getUserInfo() {
-    const token = this.getToken();
-    if (!token) return null;
-    try {
-      const claims = this.parseToken(token);
-      return {
-        address: claims.address,
-        role: claims.role
-      };
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Logout user
-   */
-  logout() {
-    if (typeof window !== "undefined") {
-      sessionStorage.removeItem(this.tokenKey);
-    }
-  }
-  /**
-   * Check if token is expiring soon (within 5 minutes)
-   */
-  isTokenExpiringSoon() {
-    const token = this.getToken();
-    if (!token) return true;
-    try {
-      const claims = this.parseToken(token);
-      const expiresAt = claims.exp * 1e3;
-      const fiveMinutes = 5 * 60 * 1e3;
-      return expiresAt - Date.now() < fiveMinutes;
-    } catch {
-      return true;
-    }
-  }
-};
-
-// src/validators.ts
-var ValidatorsAPI = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get all validators
-   * GET /eth/v1/validators
-   */
-  async getAll() {
-    return this.client.get("/eth/v1/validators");
-  }
-  /**
-   * Get validator details
-   * GET /eth/v1/validators/:address
-   */
-  async get(address) {
-    return this.client.get(`/eth/v1/validators/${address}`);
-  }
-  /**
-   * Get validator delegators
-   * GET /eth/v1/validators/:address/delegators
-   */
-  async getDelegators(address) {
-    return this.client.get(`/eth/v1/validators/${address}/delegators`);
-  }
-  /**
-   * Get validator stake breakdown
-   * GET /eth/v1/validators/:address/stake
-   */
-  async getStakeBreakdown(address) {
-    return this.client.get(`/eth/v1/validators/${address}/stake`);
+    this.token = result.token;
+    return result;
   }
-  /**
-   * Get validator epoch details
-   * GET /eth/v1/validators/:address/epochs/:epoch
-   */
-  async getEpoch(address, epoch) {
-    return this.client.get(`/eth/v1/validators/${address}/epochs/${epoch}`);
+  // ============================================
+  // Validators
+  // ============================================
+  async getValidators() {
+    return this.request("/eth/v1/validators");
   }
-  /**
-   * Get validator history
-   * GET /eth/v1/validators/:address/history
-   * @param address - Validator address
-   * @param fromEpoch - Optional starting epoch
-   * @param toEpoch - Optional ending epoch
-   */
-  async getHistory(address, fromEpoch, toEpoch) {
-    const params = {};
-    if (fromEpoch !== void 0) params.from_epoch = fromEpoch;
-    if (toEpoch !== void 0) params.to_epoch = toEpoch;
-    return this.client.get(
-      `/eth/v1/validators/${address}/history`,
-      params
-    );
+  async getActiveValidators() {
+    return this.request("/eth/v1/validators/active");
   }
-  /**
-   * Get validator withdrawals
-   * GET /eth/v1/validators/:address/withdrawals
-   * @param address - Validator address
-   * @param limit - Optional limit
-   * @param offset - Optional offset
-   */
-  async getWithdrawals(address, limit, offset) {
-    const params = {};
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get(
-      `/eth/v1/validators/${address}/withdrawals`,
-      params
-    );
+  async getCandidates() {
+    return this.request("/eth/v1/validators/candidates");
   }
-  /**
-   * Get validator metrics
-   * GET /eth/v1/validators/:address/metrics
-   */
-  async getMetrics(address) {
-    return this.client.get(`/eth/v1/validators/${address}/metrics`);
+  async getValidator(address) {
+    return this.request(`/eth/v1/validators/${address}`);
   }
-  /**
-   * Get validator slashing events
-   * GET /eth/v1/validators/:address/slashing
-   */
-  async getSlashing(address) {
-    return this.client.get(`/eth/v1/validators/${address}/slashing`);
+  async getValidatorDelegators(address) {
+    return this.request(`/eth/v1/validators/${address}/delegators`);
   }
-  /**
-   * Get validator APR
-   * GET /eth/v1/validators/:address/apr
-   */
-  async getAPR(address) {
-    return this.client.get(`/eth/v1/validators/${address}/apr`);
+  // ============================================
+  // Delegators
+  // ============================================
+  async getDelegator(address) {
+    return this.request(`/eth/v1/delegators/${address}`);
   }
-};
-
-// src/delegators.ts
-var DelegatorsAPI = class {
-  constructor(client) {
-    this.client = client;
+  async getDelegatorStakes(address) {
+    return this.request(`/eth/v1/delegators/${address}/stakes`);
   }
-  /**
-   * Get all delegators
-   * GET /eth/v1/delegators
-   */
-  async getAll() {
-    return this.client.get("/eth/v1/delegators");
+  async getDelegatorRewards(address) {
+    return this.request(`/eth/v1/delegators/${address}/rewards`);
   }
-  /**
-   * Get delegator details
-   * GET /eth/v1/delegators/:address
-   */
-  async get(address) {
-    return this.client.get(`/eth/v1/delegators/${address}`);
+  // ============================================
+  // Referral
+  // ============================================
+  async getReferralKey(key) {
+    return this.request(`/eth/v1/referral/key/${key}`);
   }
-  /**
-   * Get delegator stakes breakdown per validator
-   * GET /eth/v1/delegators/:address/stakes
-   */
-  async getStakes(address) {
-    return this.client.get(`/eth/v1/delegators/${address}/stakes`);
-  }
-  /**
-   * Get delegator rewards history
-   * GET /eth/v1/delegators/:address/rewards
-   * @param address - Delegator address
-   * @param limit - Optional limit
-   * @param offset - Optional offset
-   */
-  async getRewards(address, limit, offset) {
-    const params = {};
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get(
-      `/eth/v1/delegators/${address}/rewards`,
-      params
-    );
-  }
-  /**
-   * Get delegator withdrawals history
-   * GET /eth/v1/delegators/:address/withdrawals
-   * @param address - Delegator address
-   * @param limit - Optional limit
-   * @param offset - Optional offset
-   */
-  async getWithdrawals(address, limit, offset) {
-    const params = {};
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get(
-      `/eth/v1/delegators/${address}/withdrawals`,
-      params
-    );
-  }
-  /**
-   * Get delegator unbonding status
-   * GET /eth/v1/delegators/:address/unbonding
-   */
-  async getUnbonding(address) {
-    return this.client.get(`/eth/v1/delegators/${address}/unbonding`);
+  async getValidatorKeys(address) {
+    return this.request(`/eth/v1/referral/validator/${address}`);
   }
-  /**
-   * Get delegator active validators
-   * GET /eth/v1/delegators/:address/validators
-   */
-  async getValidators(address) {
-    return this.client.get(`/eth/v1/delegators/${address}/validators`);
-  }
-};
-
-// src/referrals.ts
-var ReferralsAPI = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Validate a referral code
-   * GET /eth/v1/referrals/validate?code=CODE
-   */
-  async validate(referralCode) {
-    return this.client.get("/eth/v1/referrals/validate", {
-      code: referralCode
+  async checkWhitelist(data) {
+    return this.request("/eth/v1/referral/whitelist", {
+      method: "POST",
+      body: JSON.stringify(data)
     });
   }
-  /**
-   * Create a new referral code
-   * POST /eth/v1/referrals
-   * @param request - Referral creation request
-   */
-  async create(request) {
-    return this.client.post("/eth/v1/referrals", request);
-  }
-  /**
-   * Apply a referral code
-   * POST /eth/v1/referrals/apply
-   * @param request - Referral application request
-   */
-  async apply(request) {
-    return this.client.post("/eth/v1/referrals/apply", request);
-  }
-  /**
-   * Delete a referral code
-   * DELETE /eth/v1/referrals/:referral_code
-   * @param referralCode - The referral code to delete
-   */
-  async delete(referralCode) {
-    return this.client.delete(`/eth/v1/referrals/${referralCode}`);
-  }
-  /**
-   * Unlink a delegator from referral
-   * DELETE /eth/v1/referrals/unlink/:delegator_address
-   * @param delegatorAddress - The delegator address to unlink
-   */
-  async unlink(delegatorAddress) {
-    return this.client.delete(`/eth/v1/referrals/unlink/${delegatorAddress}`);
+  // ============================================
+  // Geo
+  // ============================================
+  async getGeoNodes() {
+    return this.request("/eth/v1/geo/nodes");
   }
-  /**
-   * Get delegator referral information
-   * GET /eth/v1/referrals/delegators/:delegator_address
-   */
-  async getDelegatorReferral(delegatorAddress) {
-    return this.client.get(
-      `/eth/v1/referrals/delegators/${delegatorAddress}`
-    );
+  async getGeoValidators() {
+    return this.request("/eth/v1/geo/validators");
   }
-  /**
-   * Get validator referral information
-   * GET /eth/v1/referrals/validators/:validator_address
-   */
-  async getValidatorReferral(validatorAddress) {
-    return this.client.get(
-      `/eth/v1/referrals/validators/${validatorAddress}`
-    );
+  async getGeoStats() {
+    return this.request("/eth/v1/geo/stats");
   }
-};
-
-// src/global.ts
-var GlobalAPI = class {
-  constructor(client) {
-    this.client = client;
+  async updateGeoLocation(data) {
+    return this.request("/eth/v1/geo/update", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
   }
-  /**
-   * Get global network statistics
-   * GET /eth/v1/global
-   */
-  async getStats() {
-    return this.client.get("/eth/v1/global");
+  // ============================================
+  // Stats
+  // ============================================
+  async getNetworkStats() {
+    return this.request("/eth/v1/stats/network");
   }
-  /**
-   * Get network APR (from /global endpoint)
-   * GET /eth/v1/global/network_apr
-   */
-  async getNetworkAPRFromGlobal() {
-    return this.client.get("/eth/v1/global/network_apr");
+  async getCurrentEpoch() {
+    return this.request("/eth/v1/stats/epoch/current");
   }
-  /**
-   * Get network APR (from /network endpoint)
-   * GET /eth/v1/network/apr
-   */
+  // ============================================
+  // APR
+  // ============================================
   async getNetworkAPR() {
-    return this.client.get("/eth/v1/network/apr");
-  }
-  /**
-   * Get network APR breakdown
-   * GET /eth/v1/network/apr/breakdown
-   */
-  async getNetworkAPRBreakdown() {
-    return this.client.get("/eth/v1/network/apr/breakdown");
-  }
-  /**
-   * Get delegator leaderboard
-   * GET /eth/v1/leaderboard/delegators
-   * @param limit - Optional limit (default backend value)
-   * @param offset - Optional offset for pagination
-   */
-  async getLeaderboardDelegators(limit, offset) {
-    const params = {};
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get(
-      "/eth/v1/leaderboard/delegators",
-      params
-    );
-  }
-  /**
-   * Get validator leaderboard
-   * GET /eth/v1/leaderboard/validators
-   * @param limit - Optional limit (default backend value)
-   * @param offset - Optional offset for pagination
-   */
-  async getLeaderboardValidators(limit, offset) {
-    const params = {};
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get(
-      "/eth/v1/leaderboard/validators",
-      params
-    );
-  }
-};
-
-// src/slashing.ts
-var SlashingAPI = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get slashing events
-   * GET /eth/v1/slashing/events
-   * @param validatorAddress - Optional validator address filter
-   * @param limit - Optional limit
-   * @param offset - Optional offset
-   */
-  async getEvents(validatorAddress, limit, offset) {
-    const params = {};
-    if (validatorAddress) params.validator_address = validatorAddress;
-    if (limit !== void 0) params.limit = limit;
-    if (offset !== void 0) params.offset = offset;
-    return this.client.get("/eth/v1/slashing/events", params);
-  }
-};
-
-// src/modules/analytics.ts
-var AnalyticsAPI = class {
-  constructor(client) {
-    this.basePath = "/eth/v1/analytics";
-    this.client = client;
-  }
-  /**
-   * Get protocol-level statistics
-   * 
-   * Returns aggregated statistics about the entire protocol including
-   * total staking, validator counts, and rewards distribution.
-   * 
-   * @returns Protocol statistics from subgraph
-   * 
-   * @example
-   * ```typescript
-   * const stats = await sdk.analytics.getProtocolStats();
-   * console.log(`Total Staking: ${stats.TotalStaking}`);
-   * console.log(`Active Validators: ${stats.ActiveValidators}`);
-   * ```
-   */
-  async getProtocolStats() {
-    return this.client.get(`${this.basePath}/protocol`);
-  }
-  /**
-   * Get sync status of analytics workers
-   * 
-   * Returns the current synchronization status of background workers
-   * that index blockchain data into the analytics database.
-   * 
-   * @returns Sync status for each worker
-   * 
-   * @example
-   * ```typescript
-   * const status = await sdk.analytics.getSyncStatus();
-   * if (status.protocol_sync.status === 'success') {
-   *   console.log(`Last synced at block: ${status.protocol_sync.last_block}`);
-   * }
-   * ```
-   */
-  async getSyncStatus() {
-    return this.client.get(`${this.basePath}/sync-status`);
-  }
-  /**
-   * Get all validators with analytics data
-   * 
-   * Returns a paginated list of validators with their analytics metrics
-   * including uptime, signed blocks, and staker counts.
-   * 
-   * @param options - Pagination and filter options
-   * @returns Paginated list of validators
-   * 
-   * @example
-   * ```typescript
-   * // Get first 20 validators
-   * const result = await sdk.analytics.getAllValidators({ limit: 20 });
-   * 
-   * // Get next page
-   * const nextPage = await sdk.analytics.getAllValidators({ 
-   *   limit: 20, 
-   *   offset: 20 
-   * });
-   * 
-   * // Filter by status
-   * const active = await sdk.analytics.getAllValidators({ 
-   *   status: 'active',
-   *   limit: 50
-   * });
-   * ```
-   */
-  async getAllValidators(options) {
-    const params = {};
-    if (options?.limit) params.limit = options.limit;
-    if (options?.offset) params.offset = options.offset;
-    if (options?.status) params.status = options.status;
-    const response = await this.client.get(
-      `${this.basePath}/validators`,
-      params
-    );
-    if (Array.isArray(response)) {
-      return {
-        count: response.length,
-        data: response
-      };
+    return this.request("/eth/v1/apr/network");
+  }
+  async getValidatorAPR(address) {
+    return this.request(`/eth/v1/apr/validator/${address}`);
+  }
+  // ============================================
+  // Storage
+  // ============================================
+  async uploadAvatar(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const headers = {};
+    if (this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
     }
-    return response;
-  }
-  /**
-   * Get top validators by uptime
-   * 
-   * Returns validators sorted by uptime percentage in descending order.
-   * Useful for displaying leaderboards or finding most reliable validators.
-   * 
-   * @param limit - Maximum number of validators to return (default: 10)
-   * @returns Top validators by uptime
-   * 
-   * @example
-   * ```typescript
-   * // Get top 5 validators
-   * const top5 = await sdk.analytics.getTopValidators(5);
-   * 
-   * top5.data.forEach((validator, index) => {
-   *   console.log(`#${index + 1}: ${validator.moniker} - ${validator.uptime}% uptime`);
-   * });
-   * ```
-   */
-  async getTopValidators(limit = 10) {
-    const response = await this.client.get(
-      `${this.basePath}/validators/top`,
-      { limit }
-    );
-    if (Array.isArray(response)) {
-      return {
-        count: response.length,
-        data: response
-      };
+    const response = await fetch(`${this.baseUrl}/eth/v1/storage/avatar`, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Upload failed" }));
+      throw new Error(error.error);
     }
-    return response;
+    return response.json();
   }
-  /**
-   * Get analytics data for a specific validator
-   * 
-   * Returns detailed analytics metrics for a single validator including
-   * performance statistics and current status.
-   * 
-   * @param address - Validator address (with or without 0x prefix)
-   * @returns Validator analytics data
-   * 
-   * @throws {ResonanceAPIError} 404 if validator not found
-   * 
-   * @example
-   * ```typescript
-   * const validator = await sdk.analytics.getValidatorAnalytics('0x1234...');
-   * console.log(`${validator.moniker}: ${validator.uptime}% uptime`);
-   * console.log(`Signed: ${validator.signed_blocks}, Missed: ${validator.missed_blocks}`);
-   * ```
-   */
-  async getValidatorAnalytics(address) {
-    const cleanAddress = address.toLowerCase().replace(/^0x/, "");
-    return this.client.get(
-      `${this.basePath}/validators/0x${cleanAddress}`
-    );
+  async getAvatar(address) {
+    return this.request(`/eth/v1/storage/avatar/${address}`);
   }
-  /**
-   * Get validator rewards with pagination
-   * 
-   * Returns detailed reward and stake information for a validator.
-   * This is a heavy endpoint that MUST use pagination.
-   * 
-   * @param address - Validator address (with or without 0x prefix)
-   * @param options - Pagination options (required)
-   * @returns Validator rewards, stakes, and summary
-   * 
-   * @throws {ResonanceAPIError} 404 if validator not found
-   * 
-   * @remarks
-   * This endpoint can return large amounts of data. Always use pagination
-   * with reasonable limit values (recommended: 50-100).
-   * 
-   * @example
-   * ```typescript
-   * // Get first page of rewards
-   * const page1 = await sdk.analytics.getValidatorRewards('0x1234...', {
-   *   limit: 50,
-   *   offset: 0
-   * });
-   * 
-   * console.log(`Total stakers: ${page1.summary.total_stakers}`);
-   * console.log(`Has more data: ${page1.metadata.has_more}`);
-   * 
-   * // Get next page if available
-   * if (page1.metadata.has_more) {
-   *   const page2 = await sdk.analytics.getValidatorRewards('0x1234...', {
-   *     limit: 50,
-   *     offset: 50
-   *   });
-   * }
-   * ```
-   */
-  async getValidatorRewards(address, options) {
-    const cleanAddress = address.toLowerCase().replace(/^0x/, "");
-    const limit = options.limit || 50;
-    const offset = options.offset || 0;
-    return this.client.get(
-      `${this.basePath}/validators/0x${cleanAddress}/rewards`,
-      { limit, offset }
-    );
+  // ============================================
+  // Analytics
+  // ============================================
+  async getDailyBlockStats(days = 7) {
+    return this.request(`/eth/v1/analytics/blocks?days=${days}`);
   }
-  /**
-   * Get all validator rewards with automatic pagination
-   * 
-   * Automatically fetches all pages of validator rewards data.
-   * Use with caution as this can make multiple API calls.
-   * 
-   * @param address - Validator address (with or without 0x prefix)
-   * @param options - Batch size and safety limits
-   * @returns Complete validator rewards data
-   * 
-   * @throws {ResonanceAPIError} 404 if validator not found
-   * @throws {Error} If max pages limit is reached
-   * 
-   * @remarks
-   * This method will make multiple API calls. Use maxPages to prevent
-   * infinite loops or excessive API usage.
-   * 
-   * @example
-   * ```typescript
-   * // Fetch all rewards with default settings
-   * const allRewards = await sdk.analytics.getAllValidatorRewards('0x1234...');
-   * 
-   * // Custom batch size and limit
-   * const rewards = await sdk.analytics.getAllValidatorRewards('0x1234...', {
-   *   batchSize: 100,
-   *   maxPages: 5
-   * });
-   * 
-   * console.log(`Total rewards: ${rewards.summary.total_rewards}`);
-   * console.log(`Total API calls made: ${Math.ceil(rewards.stakes.length / 100)}`);
-   * ```
-   */
-  async getAllValidatorRewards(address, options) {
-    const batchSize = options?.batchSize || 50;
-    const maxPages = options?.maxPages || 10;
-    let offset = 0;
-    let page = 0;
-    let firstResponse = null;
-    const allRewards = [];
-    const allStakes = [];
-    while (page < maxPages) {
-      const response = await this.getValidatorRewards(address, {
-        limit: batchSize,
-        offset
-      });
-      if (!firstResponse) {
-        firstResponse = response;
-      }
-      allRewards.push(...response.rewards);
-      allStakes.push(...response.stakes);
-      if (!response.metadata.has_more) {
-        break;
-      }
-      offset += batchSize;
-      page++;
-    }
-    if (page >= maxPages && firstResponse?.metadata.has_more) {
-      throw new Error(
-        `Reached maximum page limit (${maxPages}). Use manual pagination for more control.`
-      );
-    }
-    return {
-      ...firstResponse,
-      rewards: allRewards,
-      stakes: allStakes,
-      metadata: {
-        ...firstResponse.metadata,
-        has_more: false,
-        limit: allRewards.length,
-        offset: 0
-      }
-    };
+  async getValidatorRewardHistory(address, limit = 100) {
+    return this.request(`/eth/v1/analytics/rewards/${address}?limit=${limit}`);
   }
 };
-
-// src/utils/analytics-helpers.ts
-function isValidatorNotFound(error) {
-  return error instanceof ResonanceAPIError && error.statusCode === 404;
-}
-function isServiceUnavailable(error) {
-  return error instanceof ResonanceAPIError && error.statusCode === 503;
-}
-function isTimeout(error) {
-  return error instanceof Error && error.message.includes("timeout");
-}
-function isStaleData(response) {
-  return response.metadata?.stale === true;
-}
-function isCachedData(response) {
-  return response.metadata?.cached === true;
-}
-function isSyncHealthy(syncStatus, workerName = "protocol_sync") {
-  const worker = syncStatus[workerName];
-  return worker?.status === "success";
-}
-function isSyncDegraded(syncStatus, workerName = "protocol_sync") {
-  const worker = syncStatus[workerName];
-  return worker?.status === "degraded";
-}
-function getSyncLag(syncStatus, currentBlock, workerName = "protocol_sync") {
-  const worker = syncStatus[workerName];
-  if (!worker?.last_block) return null;
-  return currentBlock - worker.last_block;
+function createResonanceClient(config) {
+  return new ResonanceClient(config);
 }
-function getDataFreshness(response, currentBlock) {
-  const subgraphBlock = response.metadata?.subgraph_block;
-  if (!subgraphBlock) return 0;
-  const blocksBehind = currentBlock - subgraphBlock;
-  if (blocksBehind <= 0) return 100;
-  if (blocksBehind <= 10) return 100 - blocksBehind;
-  if (blocksBehind <= 100) return 90 - Math.floor((blocksBehind - 10) * 0.44);
-  return Math.max(0, 50 - Math.floor((blocksBehind - 100) * 0.5));
-}
-function validatePagination(limit, offset) {
-  if (limit !== void 0 && (limit <= 0 || limit > 1e3)) {
-    throw new Error("Limit must be between 1 and 1000");
-  }
-  if (offset !== void 0 && offset < 0) {
-    throw new Error("Offset must be non-negative");
-  }
-}
-function getOptimalBatchSize(totalItems, maxBatchSize = 100) {
-  if (totalItems <= maxBatchSize) return totalItems;
-  const targetBatches = 7;
-  const calculatedSize = Math.ceil(totalItems / targetBatches);
-  return Math.min(calculatedSize, maxBatchSize);
-}
-function formatNumber(value) {
-  const num = typeof value === "string" ? value : value.toString();
-  return num.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-}
-function weiToEther(wei, decimals = 4) {
-  const weiNum = BigInt(wei);
-  const etherNum = Number(weiNum) / 1e18;
-  return etherNum.toFixed(decimals);
-}
-
-// src/utils/retry.ts
-function defaultShouldRetry(error, attempt) {
-  if (attempt >= 3) return false;
-  if (error instanceof Error && error.message.includes("timeout")) {
-    return true;
-  }
-  if (error.statusCode === 503) {
-    return true;
-  }
-  if (error instanceof Error && error.message.includes("fetch failed")) {
-    return true;
-  }
-  return false;
-}
-async function withRetry(fn, options = {}) {
-  const {
-    maxRetries = 3,
-    initialDelay = 1e3,
-    maxDelay = 1e4,
-    backoffMultiplier = 2,
-    shouldRetry = defaultShouldRetry,
-    onRetry
-  } = options;
-  let lastError;
-  let delay = initialDelay;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxRetries && shouldRetry(error, attempt)) {
-        if (onRetry) {
-          onRetry(error, attempt + 1, delay);
-        }
-        await sleep(delay);
-        delay = Math.min(delay * backoffMultiplier, maxDelay);
-      } else {
-        throw error;
-      }
-    }
-  }
-  throw lastError;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function createRetryWrapper(fn, options = {}) {
-  return ((...args) => {
-    return withRetry(() => fn(...args), options);
-  });
-}
-
-// src/index.ts
-var ResonanceSDK = class {
-  constructor(config) {
-    this.client = new HTTPClient(config);
-    this.auth = new AuthService(config.apiUrl);
-    this.validators = new ValidatorsAPI(this.client);
-    this.delegators = new DelegatorsAPI(this.client);
-    this.referrals = new ReferralsAPI(this.client);
-    this.global = new GlobalAPI(this.client);
-    this.slashing = new SlashingAPI(this.client);
-    this.analytics = new AnalyticsAPI(this.client);
-  }
-  /**
-   * Set authentication token for API requests
-   * @param token - JWT token
-   */
-  setAuthToken(token) {
-    this.client.setAuthToken(token);
-  }
-  /**
-   * Set custom header for API requests
-   * @param key - Header key
-   * @param value - Header value
-   */
-  setHeader(key, value) {
-    this.client.setHeader(key, value);
-  }
-  /**
-   * Get the current auth token from storage
-   */
-  getAuthToken() {
-    return this.auth.getToken();
-  }
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated() {
-    return this.auth.isAuthenticated();
-  }
-  /**
-   * Logout user and clear auth token
-   */
-  logout() {
-    this.auth.logout();
-    this.client.setAuthToken(null);
-  }
-};
-var index_default = ResonanceSDK;
 export {
-  AnalyticsAPI,
-  AuthService,
-  DelegatorsAPI,
-  GlobalAPI,
-  HTTPClient,
-  ReferralsAPI,
-  ResonanceSDK,
-  SlashingAPI,
-  ValidatorsAPI,
-  createRetryWrapper,
-  index_default as default,
-  formatNumber,
-  getDataFreshness,
-  getOptimalBatchSize,
-  getSyncLag,
-  isCachedData,
-  isServiceUnavailable,
-  isStaleData,
-  isSyncDegraded,
-  isSyncHealthy,
-  isTimeout,
-  isValidatorNotFound,
-  validatePagination,
-  weiToEther,
-  withRetry
+  ErrorCode,
+  ResonanceClient,
+  ResonanceError,
+  createResonanceClient,
+  hasErrorCode,
+  isAuthError,
+  isNetworkError,
+  isNotFoundError,
+  isResonanceError
 };