@one_deploy/sdk 1.0.3 → 1.0.5

package/dist/hooks/index.js

@@ -1046,6 +1046,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
@@ -1184,6 +1221,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);
@@ -1352,7 +1450,260 @@ 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] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const { category, riskLevel, minTvl, isActive, autoRefresh = false, refreshInterval = 6e4 } = options;
+  const fetchStrategies = react.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]);
+  react.useEffect(() => {
+    fetchStrategies();
+  }, [fetchStrategies]);
+  react.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] = react.useState(null);
+  const [performance, setPerformance] = react.useState([]);
+  const [marketData, setMarketData] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchStrategy = react.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(",")]);
+  react.useEffect(() => {
+    fetchStrategy();
+  }, [fetchStrategy]);
+  return { strategy, performance, marketData, isLoading, error, refresh: fetchStrategy };
+}
+function useAIOrders(options = {}) {
+  const [orders, setOrders] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const { strategyId, status, autoRefresh = true, refreshInterval = 3e4 } = options;
+  const fetchOrders = react.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]);
+  react.useEffect(() => {
+    fetchOrders();
+  }, [fetchOrders]);
+  react.useEffect(() => {
+    if (autoRefresh && refreshInterval > 0) {
+      const interval = setInterval(fetchOrders, refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, refreshInterval, fetchOrders]);
+  const createOrder = react.useCallback(async (request) => {
+    const result = await getClient().createAIOrder(request);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const pauseOrder = react.useCallback(async (orderId) => {
+    const result = await getClient().pauseAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const resumeOrder = react.useCallback(async (orderId) => {
+    const result = await getClient().resumeAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const redeemOrder = react.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] = react.useState(null);
+  const [allocations, setAllocations] = react.useState([]);
+  const [activeOrders, setActiveOrders] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchPortfolio = react.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);
+    }
+  }, []);
+  react.useEffect(() => {
+    fetchPortfolio();
+  }, [fetchPortfolio]);
+  react.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] = react.useState({});
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchPrices = react.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(",")]);
+  react.useEffect(() => {
+    fetchPrices();
+  }, [fetchPrices]);
+  react.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 = react.useCallback(async () => {
+    await Promise.all([
+      strategiesResult.refresh(),
+      ordersResult.refresh(),
+      portfolioResult.refresh(),
+      marketResult.refresh()
+    ]);
+  }, [strategiesResult.refresh, ordersResult.refresh, portfolioResult.refresh, marketResult.refresh]);
+  const error = react.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
+  };
+}
 
+exports.clearAITradingAccessToken = clearAITradingAccessToken;
+exports.setAITradingAccessToken = setAITradingAccessToken;
+exports.useAIMarketData = useAIMarketData;
+exports.useAIOrders = useAIOrders;
+exports.useAIPortfolio = useAIPortfolio;
+exports.useAIStrategies = useAIStrategies;
+exports.useAIStrategy = useAIStrategy;
+exports.useAITrading = useAITrading;
 exports.useTokenPrice = useTokenPrice;
 exports.useTokenPrices = useTokenPrices;
 exports.useWalletBalance = useWalletBalance;