@paxoslabs/amplify-sdk 0.1.1 → 0.2.0-alpha.1

package/dist/{chunk-CUGK4ZBJ.mjs → chunk-YDMFT2R7.mjs}

@@ -1,29 +1,91 @@
 import { defineChain } from 'viem';
 import { swellchain, sei, plumeMainnet, form, boba, mainnet } from 'viem/chains';
 
-// src/types/amplify-sdk-api.ts
-var APIError = class _APIError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "APIError";
-    this.statusCode = options?.statusCode;
-    this.endpoint = options?.endpoint;
-    this.cause = options?.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _APIError);
+// src/types/telemetry.ts
+var LogLevel = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4
+};
+
+// src/lib/logger.ts
+var ConsoleLogger = class {
+  constructor(level = LogLevel.ERROR) {
+    this.level = level;
+  }
+  /**
+   * Update log level
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Get current log level
+   */
+  getLevel() {
+    return this.level;
+  }
+  debug(message, context) {
+    if (this.level <= LogLevel.DEBUG) {
+      if (context) {
+        console.debug("[Amplify SDK]", message, context);
+      } else {
+        console.debug("[Amplify SDK]", message);
+      }
+    }
+  }
+  info(message, context) {
+    if (this.level <= LogLevel.INFO) {
+      if (context) {
+        console.info("[Amplify SDK]", message, context);
+      } else {
+        console.info("[Amplify SDK]", message);
+      }
+    }
+  }
+  warn(message, context) {
+    if (this.level <= LogLevel.WARN) {
+      if (context) {
+        console.warn("[Amplify SDK]", message, context);
+      } else {
+        console.warn("[Amplify SDK]", message);
+      }
+    }
+  }
+  error(message, context) {
+    if (this.level <= LogLevel.ERROR) {
+      if (context) {
+        console.error("[Amplify SDK]", message, context);
+      } else {
+        console.error("[Amplify SDK]", message);
+      }
     }
   }
 };
-function isValidYieldType(value) {
-  return typeof value === "string" && (value === "PRIME" || value === "TBILL" || value === "LENDING");
+var currentLogger = new ConsoleLogger(LogLevel.ERROR);
+var defaultLogger = currentLogger;
+function setLogger(logger) {
+  currentLogger = logger;
 }
-function isValidAddress(value) {
-  return typeof value === "string" && /^0x[a-fA-F0-9]{40}$/.test(value);
+function getLogger() {
+  return currentLogger;
 }
-function isValidChainId(value) {
-  return typeof value === "number" && value > 0 && Number.isInteger(value);
+function setLogLevel(level) {
+  if (defaultLogger && typeof defaultLogger.setLevel === "function") {
+    defaultLogger.setLevel(level);
+  }
 }
 
+// src/constants/index.ts
+var ATOMIC_QUEUE_CONTRACT_ADDRESS = "0x228c44bb4885c6633f4b6c83f14622f37d5112e5";
+var DEFAULT_DEADLINE = 3;
+var NATIVE_TOKEN_FOR_BRIDGE_FEE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var CHAINLINK_ADDRESS = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419";
+var DEFAULT_APPROVAL_AMOUNT = BigInt(2) ** BigInt(256) - BigInt(1);
+var API_BASE_URL = "https://api.paxoslabs.com";
+
 // src/lib/vault-cache.ts
 var DEFAULT_TTL = 6e5;
 var VaultCache = class {
@@ -191,7 +253,6 @@ var VaultCache = class {
 };
 
 // src/api/amplify-sdk-client.ts
-var API_BASE_URL = "https://api.paxoslabs.com";
 var DEFAULT_TIMEOUT = 1e4;
 function createTimeoutSignal(timeoutMs) {
   const controller = new AbortController();
@@ -617,7 +678,8 @@ var sdkConfig = {
   isInitialized: false,
   initializedAt: null,
   isInitializing: false,
-  initPromise: null
+  initPromise: null,
+  telemetryEnabled: true
 };
 var ERROR_MESSAGES = {
   INVALID_API_KEY: "Invalid API key format. Expected format: pxl_<type>_<string>",
@@ -650,6 +712,8 @@ function clearConfig() {
   sdkConfig.initializedAt = null;
   sdkConfig.isInitializing = false;
   sdkConfig.initPromise = null;
+  sdkConfig.telemetryEnabled = true;
+  resetTelemetry();
 }
 function getRequestHeaders() {
   const apiKey = getAPIKey();
@@ -661,7 +725,7 @@ function getRequestHeaders() {
   }
   return headers;
 }
-async function initAmplifySDK(apiKey) {
+async function initAmplifySDK(apiKey, options) {
   validateAPIKey(apiKey);
   if (sdkConfig.isInitialized && sdkConfig.apiKey === apiKey) {
     return;
@@ -674,6 +738,13 @@ async function initAmplifySDK(apiKey) {
     clearConfig();
     clearCache();
   }
+  if (options?.logger) {
+    setLogger(options.logger);
+  }
+  if (options?.logLevel !== void 0) {
+    setLogLevel(options.logLevel);
+  }
+  sdkConfig.telemetryEnabled = options?.telemetry !== false;
   sdkConfig.isInitializing = true;
   sdkConfig.initPromise = (async () => {
     try {
@@ -682,6 +753,10 @@ async function initAmplifySDK(apiKey) {
       await cache.refresh();
       sdkConfig.isInitialized = true;
       sdkConfig.initializedAt = /* @__PURE__ */ new Date();
+      if (sdkConfig.telemetryEnabled) {
+        initTelemetry(apiKey).catch(() => {
+        });
+      }
     } catch (error) {
       clearConfig();
       clearCache();
@@ -699,6 +774,213 @@ async function initAmplifySDK(apiKey) {
   })();
   await sdkConfig.initPromise;
 }
+
+// src/lib/telemetry.ts
+var SDK_VERSION = "0.1.1-beta.1";
+var MAX_ERROR_BUFFER_SIZE = 10;
+var CONFIG_FETCH_TIMEOUT = 5e3;
+var telemetryState = {
+  enabled: false,
+  isInitialized: false,
+  isInitializing: false,
+  initPromise: null,
+  config: null,
+  apiKey: null
+};
+var posthogClient = null;
+var errorBuffer = [];
+var bufferFullWarningLogged = false;
+function createTimeoutSignal2(timeoutMs) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeoutMs);
+  return controller.signal;
+}
+function hashApiKey(apiKey) {
+  const FNV_OFFSET = BigInt("0xcbf29ce484222325");
+  const FNV_PRIME = BigInt("0x100000001b3");
+  let hash = FNV_OFFSET;
+  for (let i = 0; i < apiKey.length; i++) {
+    hash ^= BigInt(apiKey.charCodeAt(i));
+    hash = hash * FNV_PRIME & BigInt("0xffffffffffffffff");
+  }
+  return `sdk_${hash.toString(16).slice(0, 12)}`;
+}
+async function fetchTelemetryConfig(apiKey) {
+  const endpoint = "/v1/earn-sdk/config";
+  const url = `${API_BASE_URL}${endpoint}`;
+  try {
+    const headers = getRequestHeaders();
+    if (!headers["x-api-key"]) {
+      headers["x-api-key"] = apiKey;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: createTimeoutSignal2(CONFIG_FETCH_TIMEOUT)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (!data || typeof data.posthogApiKey !== "string") {
+      return null;
+    }
+    return {
+      posthogApiKey: data.posthogApiKey,
+      posthogHost: data.posthogHost || "https://us.i.posthog.com"
+    };
+  } catch {
+    return null;
+  }
+}
+async function flushErrorBuffer() {
+  if (errorBuffer.length === 0 || !posthogClient) {
+    return;
+  }
+  for (const bufferedError of errorBuffer) {
+    const payload = {
+      error_type: bufferedError.name,
+      error_message: bufferedError.message,
+      error_code: bufferedError.code,
+      sdk_version: SDK_VERSION,
+      buffered: true,
+      ...bufferedError.context
+    };
+    posthogClient.capture("sdk_error", payload);
+  }
+  errorBuffer.length = 0;
+}
+async function initTelemetry(apiKey) {
+  if (telemetryState.isInitialized) {
+    return;
+  }
+  if (telemetryState.isInitializing && telemetryState.initPromise) {
+    await telemetryState.initPromise;
+    return;
+  }
+  telemetryState.isInitializing = true;
+  telemetryState.apiKey = apiKey;
+  telemetryState.initPromise = (async () => {
+    try {
+      const config = await fetchTelemetryConfig(apiKey);
+      if (!config) {
+        telemetryState.enabled = false;
+        telemetryState.isInitialized = true;
+        return;
+      }
+      telemetryState.config = config;
+      const posthogModule = await import('posthog-js');
+      const posthog = posthogModule.default;
+      posthog.init(config.posthogApiKey, {
+        api_host: config.posthogHost,
+        autocapture: false,
+        capture_pageview: false,
+        capture_pageleave: false,
+        disable_session_recording: true,
+        persistence: "memory",
+        // Don't persist to localStorage
+        loaded: (ph) => {
+          ph.identify(hashApiKey(apiKey));
+        }
+      });
+      posthogClient = posthog;
+      telemetryState.enabled = true;
+      telemetryState.isInitialized = true;
+      await flushErrorBuffer();
+      posthog.capture("sdk_initialized", {
+        sdk_version: SDK_VERSION
+      });
+    } catch (error) {
+      const logger = getLogger();
+      logger.warn("Telemetry initialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      telemetryState.enabled = false;
+      telemetryState.isInitialized = true;
+    } finally {
+      telemetryState.isInitializing = false;
+      telemetryState.initPromise = null;
+    }
+  })();
+  await telemetryState.initPromise;
+}
+function trackError(error, context) {
+  const logger = getLogger();
+  logger.error(error.message, {
+    name: error.name,
+    stack: error.stack,
+    ...context
+  });
+  const errorDetails = {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+    context: context || {},
+    timestamp: Date.now()
+  };
+  if (!posthogClient || !telemetryState.enabled) {
+    if (errorBuffer.length < MAX_ERROR_BUFFER_SIZE) {
+      errorBuffer.push(errorDetails);
+    } else if (!bufferFullWarningLogged) {
+      logger.warn(
+        `Telemetry error buffer full (${MAX_ERROR_BUFFER_SIZE} errors). Additional errors will not be tracked until telemetry initializes.`
+      );
+      bufferFullWarningLogged = true;
+    }
+    return;
+  }
+  const payload = {
+    error_type: error.name,
+    error_message: error.message,
+    error_code: error.code,
+    endpoint: error.endpoint,
+    status_code: error.statusCode,
+    sdk_version: SDK_VERSION,
+    ...context
+  };
+  posthogClient.capture("sdk_error", payload);
+}
+function resetTelemetry() {
+  telemetryState.enabled = false;
+  telemetryState.isInitialized = false;
+  telemetryState.isInitializing = false;
+  telemetryState.initPromise = null;
+  telemetryState.config = null;
+  telemetryState.apiKey = null;
+  posthogClient = null;
+  errorBuffer.length = 0;
+  bufferFullWarningLogged = false;
+}
+
+// src/types/amplify-sdk-api.ts
+var APIError = class _APIError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = options?.statusCode;
+    this.endpoint = options?.endpoint;
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _APIError);
+    }
+    try {
+      trackError(this, {
+        endpoint: this.endpoint,
+        statusCode: this.statusCode
+      });
+    } catch {
+    }
+  }
+};
+function isValidYieldType(value) {
+  return typeof value === "string" && (value === "PRIME" || value === "TBILL" || value === "LENDING");
+}
+function isValidAddress(value) {
+  return typeof value === "string" && /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function isValidChainId(value) {
+  return typeof value === "number" && value > 0 && Number.isInteger(value);
+}
 var rari = defineChain({
   id: 1380012617,
   name: "Rari Chain",
@@ -801,14 +1083,6 @@ function clearChainsCache() {
   chainsCache = null;
 }
 
-// src/constants/index.ts
-var ATOMIC_QUEUE_CONTRACT_ADDRESS = "0x228c44bb4885c6633f4b6c83f14622f37d5112e5";
-var DEFAULT_DEADLINE = 3;
-var NATIVE_TOKEN_FOR_BRIDGE_FEE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-var CHAINLINK_ADDRESS = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419";
-var DEFAULT_APPROVAL_AMOUNT = BigInt(2) ** BigInt(256) - BigInt(1);
-var NUCLEUS_BASE_URL = "https://backend.nucleusearn.io/v1/protocol";
-
-export { APIError, ATOMIC_QUEUE_CONTRACT_ADDRESS, CHAINLINK_ADDRESS, DEFAULT_APPROVAL_AMOUNT, DEFAULT_DEADLINE, NATIVE_TOKEN_FOR_BRIDGE_FEE, NUCLEUS_BASE_URL, clearChainsCache, fetchSupportedAssets, fetchVaults, findVaultByConfig, getAssetsFromCache, getCache, getChainFromConfig, getWithdrawSupportedAssets, initAmplifySDK, initializeCache, refreshVaultCache };
-//# sourceMappingURL=chunk-CUGK4ZBJ.mjs.map
-//# sourceMappingURL=chunk-CUGK4ZBJ.mjs.map
+export { APIError, API_BASE_URL, ATOMIC_QUEUE_CONTRACT_ADDRESS, CHAINLINK_ADDRESS, DEFAULT_APPROVAL_AMOUNT, DEFAULT_DEADLINE, LogLevel, NATIVE_TOKEN_FOR_BRIDGE_FEE, clearChainsCache, fetchSupportedAssets, fetchVaults, findVaultByConfig, getAssetsFromCache, getCache, getChainFromConfig, getLogger, getWithdrawSupportedAssets, initAmplifySDK, initializeCache, refreshVaultCache, setLogLevel, setLogger };
+//# sourceMappingURL=chunk-YDMFT2R7.mjs.map
+//# sourceMappingURL=chunk-YDMFT2R7.mjs.map