@one_deploy/sdk 1.0.3 → 1.0.5

package/dist/index.mjs

@@ -1269,6 +1269,43 @@ var OneEngineClient = class {
   async adminClearRateLimits(identifier) {
     return this.request(`/api/v1/admin/rate-limits/${identifier}`, { method: "DELETE" });
   }
+  // ========== AI Agent Configuration ==========
+  /**
+   * Get all AI agent configurations
+   * This returns the full agent setup including tiers, cycles, and trading parameters
+   */
+  async getAgentConfigs(options) {
+    const params = new URLSearchParams();
+    if (options?.includeInactive) params.set("includeInactive", "true");
+    if (options?.agentId) params.set("agentId", options.agentId);
+    const query = params.toString();
+    return this.request(`/api/v1/agents${query ? `?${query}` : ""}`, { method: "GET" });
+  }
+  /**
+   * Calculate subscription parameters for an agent
+   */
+  async calculateAgentParams(params) {
+    return this.request("/api/v1/agents/calculate", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get supported trading pairs from agents
+   */
+  async getTradingPairs() {
+    const result = await this.getAgentConfigs();
+    if (result.success && result.data?.agents) {
+      const allPairs = /* @__PURE__ */ new Set();
+      const byAgent = {};
+      for (const agent of result.data.agents) {
+        byAgent[agent.id] = agent.supported_pairs;
+        agent.supported_pairs.forEach((p) => allPairs.add(p));
+      }
+      return { success: true, data: { pairs: Array.from(allPairs), byAgent } };
+    }
+    return { success: false, error: result.error };
+  }
   // ========== AI Quant Trading ==========
   /**
    * Get all AI trading strategies
@@ -1407,6 +1444,67 @@ var OneEngineClient = class {
   async getCryptoMarketOverview() {
     return this.request("/api/v1/prices?type=overview", { method: "GET" });
   }
+  // ========== Project Management ==========
+  /**
+   * Get user's projects
+   */
+  async getProjects(options) {
+    const params = new URLSearchParams();
+    if (options?.isActive !== void 0) params.set("isActive", String(options.isActive));
+    const query = params.toString();
+    return this.request(`/api/v1/projects${query ? `?${query}` : ""}`, { method: "GET" });
+  }
+  /**
+   * Create a new project for ecosystem partners
+   */
+  async createProject(params) {
+    return this.request("/api/v1/projects", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Get project details
+   */
+  async getProject(projectId) {
+    return this.request(`/api/v1/projects/${projectId}`, { method: "GET" });
+  }
+  /**
+   * Update project settings
+   */
+  async updateProject(projectId, updates) {
+    return this.request(`/api/v1/projects/${projectId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+  }
+  /**
+   * Get project features status
+   */
+  async getProjectFeatures(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/features`, { method: "GET" });
+  }
+  /**
+   * Enable/disable features for a project
+   */
+  async updateProjectFeatures(projectId, features) {
+    return this.request(`/api/v1/projects/${projectId}/features`, {
+      method: "PATCH",
+      body: JSON.stringify(features)
+    });
+  }
+  /**
+   * Regenerate project API key
+   */
+  async regenerateProjectApiKey(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/api-key`, { method: "POST" });
+  }
+  /**
+   * Delete project
+   */
+  async deleteProject(projectId) {
+    return this.request(`/api/v1/projects/${projectId}`, { method: "DELETE" });
+  }
 };
 function createOneEngineClient(options) {
   return new OneEngineClient(options);
@@ -3459,7 +3557,7 @@ var TOKENS_BY_CHAIN = {
     { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", name: "Ethereum", decimals: 18, chainId: 1 },
     { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", symbol: "USDC", name: "USD Coin", decimals: 6, chainId: 1 },
     { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", symbol: "USDT", name: "Tether", decimals: 6, chainId: 1 },
-    { address: "0x6B175474E89094C44Da98b954EescdeCB5", symbol: "DAI", name: "Dai", decimals: 18, chainId: 1 },
+    { address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", symbol: "DAI", name: "Dai", decimals: 18, chainId: 1 },
     { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", symbol: "WETH", name: "Wrapped Ether", decimals: 18, chainId: 1 }
   ],
   // Base
@@ -4805,6 +4903,251 @@ function useTokenPrices(symbols, options = {}) {
     refetch: fetchPrices
   };
 }
+var clientInstance = null;
+function getClient() {
+  if (!clientInstance) {
+    clientInstance = createOneEngineClient();
+  }
+  return clientInstance;
+}
+function setAITradingAccessToken(token) {
+  getClient().setAccessToken(token);
+}
+function clearAITradingAccessToken() {
+  getClient().clearAccessToken();
+}
+function useAIStrategies(options = {}) {
+  const [strategies, setStrategies] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const { category, riskLevel, minTvl, isActive, autoRefresh = false, refreshInterval = 6e4 } = options;
+  const fetchStrategies = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAIStrategies({ category, riskLevel, minTvl, isActive });
+      if (result.success && result.data?.strategies) {
+        setStrategies(result.data.strategies);
+      } else {
+        setError(result.error?.message || "Failed to fetch strategies");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [category, riskLevel, minTvl, isActive]);
+  useEffect(() => {
+    fetchStrategies();
+  }, [fetchStrategies]);
+  useEffect(() => {
+    if (autoRefresh && refreshInterval > 0) {
+      const interval = setInterval(fetchStrategies, refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, refreshInterval, fetchStrategies]);
+  return { strategies, isLoading, error, refresh: fetchStrategies };
+}
+function useAIStrategy(strategyId, include = ["performance", "market"]) {
+  const [strategy, setStrategy] = useState(null);
+  const [performance, setPerformance] = useState([]);
+  const [marketData, setMarketData] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchStrategy = useCallback(async () => {
+    if (!strategyId) {
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAIStrategy(strategyId, include);
+      if (result.success && result.data) {
+        setStrategy(result.data.strategy);
+        setPerformance(result.data.performance || []);
+        setMarketData(result.data.marketData || []);
+      } else {
+        setError(result.error?.message || "Failed to fetch strategy");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [strategyId, include.join(",")]);
+  useEffect(() => {
+    fetchStrategy();
+  }, [fetchStrategy]);
+  return { strategy, performance, marketData, isLoading, error, refresh: fetchStrategy };
+}
+function useAIOrders(options = {}) {
+  const [orders, setOrders] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const { strategyId, status, autoRefresh = true, refreshInterval = 3e4 } = options;
+  const fetchOrders = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAIOrders({ strategyId, status });
+      if (result.success && result.data?.orders) {
+        setOrders(result.data.orders);
+      } else {
+        setError(result.error?.message || "Failed to fetch orders");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [strategyId, status]);
+  useEffect(() => {
+    fetchOrders();
+  }, [fetchOrders]);
+  useEffect(() => {
+    if (autoRefresh && refreshInterval > 0) {
+      const interval = setInterval(fetchOrders, refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, refreshInterval, fetchOrders]);
+  const createOrder = useCallback(async (request) => {
+    const result = await getClient().createAIOrder(request);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const pauseOrder = useCallback(async (orderId) => {
+    const result = await getClient().pauseAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const resumeOrder = useCallback(async (orderId) => {
+    const result = await getClient().resumeAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const redeemOrder = useCallback(async (orderId) => {
+    const result = await getClient().redeemAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  return {
+    orders,
+    isLoading,
+    error,
+    refresh: fetchOrders,
+    createOrder,
+    pauseOrder,
+    resumeOrder,
+    redeemOrder
+  };
+}
+function useAIPortfolio(autoRefresh = true) {
+  const [portfolio, setPortfolio] = useState(null);
+  const [allocations, setAllocations] = useState([]);
+  const [activeOrders, setActiveOrders] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchPortfolio = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getAIPortfolio(["allocations", "orders"]);
+      if (result.success && result.data) {
+        setPortfolio(result.data.portfolio);
+        setAllocations(result.data.allocations || []);
+        setActiveOrders(result.data.orders || []);
+      } else {
+        setError(result.error?.message || "Failed to fetch portfolio");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    fetchPortfolio();
+  }, [fetchPortfolio]);
+  useEffect(() => {
+    if (autoRefresh) {
+      const interval = setInterval(fetchPortfolio, 3e4);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, fetchPortfolio]);
+  return { portfolio, allocations, activeOrders, isLoading, error, refresh: fetchPortfolio };
+}
+function useAIMarketData(symbols = ["BTC", "ETH", "BNB", "SOL", "XRP", "DOGE", "ADA", "AVAX"], autoRefresh = true) {
+  const [prices, setPrices] = useState({});
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchPrices = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await getClient().getTokenPrices(symbols);
+      if (result.success && result.data) {
+        setPrices(result.data);
+      } else {
+        setError(result.error?.message || "Failed to fetch prices");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Unknown error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [symbols.join(",")]);
+  useEffect(() => {
+    fetchPrices();
+  }, [fetchPrices]);
+  useEffect(() => {
+    if (autoRefresh) {
+      const interval = setInterval(fetchPrices, 15e3);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, fetchPrices]);
+  return { prices, isLoading, error, refresh: fetchPrices };
+}
+function useAITrading() {
+  const strategiesResult = useAIStrategies({ autoRefresh: true });
+  const ordersResult = useAIOrders({ autoRefresh: true });
+  const portfolioResult = useAIPortfolio(true);
+  const marketResult = useAIMarketData();
+  const refreshAll = useCallback(async () => {
+    await Promise.all([
+      strategiesResult.refresh(),
+      ordersResult.refresh(),
+      portfolioResult.refresh(),
+      marketResult.refresh()
+    ]);
+  }, [strategiesResult.refresh, ordersResult.refresh, portfolioResult.refresh, marketResult.refresh]);
+  const error = useMemo(() => {
+    return strategiesResult.error || ordersResult.error || portfolioResult.error || marketResult.error;
+  }, [strategiesResult.error, ordersResult.error, portfolioResult.error, marketResult.error]);
+  return {
+    strategies: strategiesResult.strategies,
+    strategiesLoading: strategiesResult.isLoading,
+    orders: ordersResult.orders,
+    ordersLoading: ordersResult.isLoading,
+    portfolio: portfolioResult.portfolio,
+    portfolioLoading: portfolioResult.isLoading,
+    prices: marketResult.prices,
+    createOrder: ordersResult.createOrder,
+    pauseOrder: ordersResult.pauseOrder,
+    resumeOrder: ordersResult.resumeOrder,
+    redeemOrder: ordersResult.redeemOrder,
+    refreshAll,
+    error
+  };
+}
 
 // src/utils/index.ts
 function shortenAddress(address, chars = 4) {
@@ -4945,6 +5288,6 @@ function isOneSDKError(error) {
   return error instanceof OneSDKError;
 }
 
-export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, OneApproveButton, OneBalanceDisplay, OneBuyBTCWidget, OneBuyETHWidget, OneBuyUSDCWidget, OneBuyUSDTWidget, OneConnectButton, OneConnectButtonFull, OneConnectButtonSimple, OneContext, OneCrossChainSwap, OneCryptoOnlyPayWidget, OneDirectPayWidget, OneEngineClient, OneFiatOnlyPayWidget, OneFundWalletWidget, OneNFTGallery, OneOfframpWidget, OneOnrampWidget, OnePayWidget, OneProvider, OneReceiveWidget, OneSDKError, OneSameChainSwap, OneSellETHWidget, OneSellUSDCWidget, OneSellUSDTWidget, OneSendETHButton, OneSendETHWidget, OneSendUSDCWidget, OneSendWidget, OneSwapWidget, OneThirdwebProvider, OneTransactionButton, OneWalletBalance, PriceService, SUPPORTED_CHAINS, SupabaseService, TOKEN_NAMES, capitalize, checksumAddress, createOneEngineClient, createSupabaseClient, fetchChains, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatTokenAmount, formatUSD2 as formatUSD, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, pick, priceService, retry, shortenAddress, sleep, slugify, truncate, useOne, useOneAuth, useOneEngine, useOneOnramp, useOneSwap, useOneTrading, useOneWallet, useThirdwebClient, useTokenPrice, useTokenPrices, useWalletBalance2 as useWalletBalance };
+export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, OneApproveButton, OneBalanceDisplay, OneBuyBTCWidget, OneBuyETHWidget, OneBuyUSDCWidget, OneBuyUSDTWidget, OneConnectButton, OneConnectButtonFull, OneConnectButtonSimple, OneContext, OneCrossChainSwap, OneCryptoOnlyPayWidget, OneDirectPayWidget, OneEngineClient, OneFiatOnlyPayWidget, OneFundWalletWidget, OneNFTGallery, OneOfframpWidget, OneOnrampWidget, OnePayWidget, OneProvider, OneReceiveWidget, OneSDKError, OneSameChainSwap, OneSellETHWidget, OneSellUSDCWidget, OneSellUSDTWidget, OneSendETHButton, OneSendETHWidget, OneSendUSDCWidget, OneSendWidget, OneSwapWidget, OneThirdwebProvider, OneTransactionButton, OneWalletBalance, PriceService, SUPPORTED_CHAINS, SupabaseService, TOKEN_NAMES, capitalize, checksumAddress, clearAITradingAccessToken, createOneEngineClient, createSupabaseClient, fetchChains, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatTokenAmount, formatUSD2 as formatUSD, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, pick, priceService, retry, setAITradingAccessToken, shortenAddress, sleep, slugify, truncate, useAIMarketData, useAIOrders, useAIPortfolio, useAIStrategies, useAIStrategy, useAITrading, useOne, useOneAuth, useOneEngine, useOneOnramp, useOneSwap, useOneTrading, useOneWallet, useThirdwebClient, useTokenPrice, useTokenPrices, useWalletBalance2 as useWalletBalance };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map