@one_deploy/sdk 1.0.3 → 1.0.5

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, OneConfig, SUPPORTED_CHAINS, TOKEN_NAMES, fetchChains, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized } from './config/index.mjs';
 export { AIMarketData, AINavSnapshot, AIOrder, AIOrderStatus, AIPortfolioSummary, AIRedemptionResult, AIStrategy, AITradeAllocation, AITradeExecution, AdminListOptions, AdminProject, AdminUser, ApiResponse, AssetAllocation, BillCategory, BillPayment, BillProvider, BridgeQuote, BridgeRoute, BridgeTransaction, Card, CardStatus, CardTier, CardTransaction, ChainConfig, Contract, ContractDeployParams, ContractReadParams, ContractType, ContractWriteParams, CreateAIOrderRequest, CreateWebhookInput, GasEstimate, GasPrice, KycLevel, KycStatus, LimitOrder, MembershipTier, NFT, NFTAttribute, NFTCollection, NFTTransfer, Notification, NotificationSettings, OfframpRequest, OnChainBalance, PaginatedResult, Permission, PermissionScope, PortfolioAnalytics, PortfolioHistory, Position, RateLimitInfo, Referral, ReferralInfo, RiskLevel, SDKEvent, SDKEventType, Session, StakingPool, StakingPosition, StrategyCategory, SystemLog, SystemStats, Token, TokenPrice, TradeAction, TradingCondition, Transaction, TransactionStatus, TransactionType, UpdateWebhookInput, User, UserProfile, UserSettings, WalletBalance, WalletExport, WalletImportRequest, Webhook, WebhookDelivery, WebhookEventType } from './types/index.mjs';
-export { E as EngineAuthResponse, b as EngineTransactionRequest, d as EngineTransactionResponse, a as EngineWalletBalance, O as OneEngineClient, g as OnrampQuote, f as OnrampSession, e as OnrampSessionRequest, h as OnrampTransaction, j as SwapExecuteRequest, i as SwapQuote, S as SwapQuoteRequest, k as SwapResult, c as createOneEngineClient } from './engine-CrlhH0nw.mjs';
-export { SupabaseService, createSupabaseClient } from './services/index.mjs';
+export { E as EngineAuthResponse, b as EngineTransactionRequest, d as EngineTransactionResponse, a as EngineWalletBalance, O as OneEngineClient, g as OnrampQuote, f as OnrampSession, e as OnrampSessionRequest, h as OnrampTransaction, j as SwapExecuteRequest, i as SwapQuote, S as SwapQuoteRequest, k as SwapResult, c as createOneEngineClient } from './engine-BeVuHpVx.mjs';
+export { S as SupabaseService, c as createSupabaseClient } from './supabase-BT0c7q9e.mjs';
 export { P as PriceService, p as priceService } from './price-ClbLHHjv.mjs';
 export { OneContext, OneProvider, OneThirdwebConfig, OneThirdwebProvider, OneThirdwebProviderProps, useOne, useOneAuth, useOneEngine, useOneOnramp, useOneSwap, useOneTrading, useOneWallet, useThirdwebClient } from './providers/index.mjs';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -11,7 +11,7 @@ export { inAppWallet, smartWallet } from 'thirdweb/wallets';
 import { PreparedTransaction } from 'thirdweb';
 import { Chain } from 'thirdweb/chains';
 export { arbitrum, base, ethereum, optimism, polygon } from 'thirdweb/chains';
-export { useTokenPrice, useTokenPrices, useWalletBalance } from './hooks/index.mjs';
+export { UseAIMarketDataResult, UseAIOrdersOptions, UseAIOrdersResult, UseAIPortfolioResult, UseAIStrategiesOptions, UseAIStrategiesResult, UseAIStrategyResult, UseAITradingResult, clearAITradingAccessToken, setAITradingAccessToken, useAIMarketData, useAIOrders, useAIPortfolio, useAIStrategies, useAIStrategy, useAITrading, useTokenPrice, useTokenPrices, useWalletBalance } from './hooks/index.mjs';
 export { OneSDKError, capitalize, checksumAddress, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatTokenAmount, formatUSD, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, pick, retry, shortenAddress, sleep, slugify, truncate } from './utils/index.mjs';
 import '@supabase/supabase-js';
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, OneConfig, SUPPORTED_CHAINS, TOKEN_NAMES, fetchChains, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized } from './config/index.js';
 export { AIMarketData, AINavSnapshot, AIOrder, AIOrderStatus, AIPortfolioSummary, AIRedemptionResult, AIStrategy, AITradeAllocation, AITradeExecution, AdminListOptions, AdminProject, AdminUser, ApiResponse, AssetAllocation, BillCategory, BillPayment, BillProvider, BridgeQuote, BridgeRoute, BridgeTransaction, Card, CardStatus, CardTier, CardTransaction, ChainConfig, Contract, ContractDeployParams, ContractReadParams, ContractType, ContractWriteParams, CreateAIOrderRequest, CreateWebhookInput, GasEstimate, GasPrice, KycLevel, KycStatus, LimitOrder, MembershipTier, NFT, NFTAttribute, NFTCollection, NFTTransfer, Notification, NotificationSettings, OfframpRequest, OnChainBalance, PaginatedResult, Permission, PermissionScope, PortfolioAnalytics, PortfolioHistory, Position, RateLimitInfo, Referral, ReferralInfo, RiskLevel, SDKEvent, SDKEventType, Session, StakingPool, StakingPosition, StrategyCategory, SystemLog, SystemStats, Token, TokenPrice, TradeAction, TradingCondition, Transaction, TransactionStatus, TransactionType, UpdateWebhookInput, User, UserProfile, UserSettings, WalletBalance, WalletExport, WalletImportRequest, Webhook, WebhookDelivery, WebhookEventType } from './types/index.js';
-export { E as EngineAuthResponse, b as EngineTransactionRequest, d as EngineTransactionResponse, a as EngineWalletBalance, O as OneEngineClient, g as OnrampQuote, f as OnrampSession, e as OnrampSessionRequest, h as OnrampTransaction, j as SwapExecuteRequest, i as SwapQuote, S as SwapQuoteRequest, k as SwapResult, c as createOneEngineClient } from './engine-5ndtBaCr.js';
-export { SupabaseService, createSupabaseClient } from './services/index.js';
+export { E as EngineAuthResponse, b as EngineTransactionRequest, d as EngineTransactionResponse, a as EngineWalletBalance, O as OneEngineClient, g as OnrampQuote, f as OnrampSession, e as OnrampSessionRequest, h as OnrampTransaction, j as SwapExecuteRequest, i as SwapQuote, S as SwapQuoteRequest, k as SwapResult, c as createOneEngineClient } from './engine-DSc1Em4V.js';
+export { S as SupabaseService, c as createSupabaseClient } from './supabase-BT0c7q9e.js';
 export { P as PriceService, p as priceService } from './price-CgqXPnT3.js';
 export { OneContext, OneProvider, OneThirdwebConfig, OneThirdwebProvider, OneThirdwebProviderProps, useOne, useOneAuth, useOneEngine, useOneOnramp, useOneSwap, useOneTrading, useOneWallet, useThirdwebClient } from './providers/index.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
@@ -11,7 +11,7 @@ export { inAppWallet, smartWallet } from 'thirdweb/wallets';
 import { PreparedTransaction } from 'thirdweb';
 import { Chain } from 'thirdweb/chains';
 export { arbitrum, base, ethereum, optimism, polygon } from 'thirdweb/chains';
-export { useTokenPrice, useTokenPrices, useWalletBalance } from './hooks/index.js';
+export { UseAIMarketDataResult, UseAIOrdersOptions, UseAIOrdersResult, UseAIPortfolioResult, UseAIStrategiesOptions, UseAIStrategiesResult, UseAIStrategyResult, UseAITradingResult, clearAITradingAccessToken, setAITradingAccessToken, useAIMarketData, useAIOrders, useAIPortfolio, useAIStrategies, useAIStrategy, useAITrading, useTokenPrice, useTokenPrices, useWalletBalance } from './hooks/index.js';
 export { OneSDKError, capitalize, checksumAddress, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatTokenAmount, formatUSD, isOneSDKError, isValidAddress, isValidEmail, isValidPhone, omit, pick, retry, shortenAddress, sleep, slugify, truncate } from './utils/index.js';
 import '@supabase/supabase-js';
 

package/dist/index.js

@@ -1273,6 +1273,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
@@ -1411,6 +1448,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);
@@ -3463,7 +3561,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
@@ -4809,6 +4907,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] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
+  const { category, riskLevel, minTvl, isActive, autoRefresh = false, refreshInterval = 6e4 } = options;
+  const fetchStrategies = React2.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]);
+  React2.useEffect(() => {
+    fetchStrategies();
+  }, [fetchStrategies]);
+  React2.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] = React2.useState(null);
+  const [performance, setPerformance] = React2.useState([]);
+  const [marketData, setMarketData] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
+  const fetchStrategy = React2.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(",")]);
+  React2.useEffect(() => {
+    fetchStrategy();
+  }, [fetchStrategy]);
+  return { strategy, performance, marketData, isLoading, error, refresh: fetchStrategy };
+}
+function useAIOrders(options = {}) {
+  const [orders, setOrders] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
+  const { strategyId, status, autoRefresh = true, refreshInterval = 3e4 } = options;
+  const fetchOrders = React2.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]);
+  React2.useEffect(() => {
+    fetchOrders();
+  }, [fetchOrders]);
+  React2.useEffect(() => {
+    if (autoRefresh && refreshInterval > 0) {
+      const interval = setInterval(fetchOrders, refreshInterval);
+      return () => clearInterval(interval);
+    }
+  }, [autoRefresh, refreshInterval, fetchOrders]);
+  const createOrder = React2.useCallback(async (request) => {
+    const result = await getClient().createAIOrder(request);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const pauseOrder = React2.useCallback(async (orderId) => {
+    const result = await getClient().pauseAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const resumeOrder = React2.useCallback(async (orderId) => {
+    const result = await getClient().resumeAIOrder(orderId);
+    if (result.success) {
+      await fetchOrders();
+    }
+    return result;
+  }, [fetchOrders]);
+  const redeemOrder = React2.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] = React2.useState(null);
+  const [allocations, setAllocations] = React2.useState([]);
+  const [activeOrders, setActiveOrders] = React2.useState([]);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
+  const fetchPortfolio = React2.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);
+    }
+  }, []);
+  React2.useEffect(() => {
+    fetchPortfolio();
+  }, [fetchPortfolio]);
+  React2.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] = React2.useState({});
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const [error, setError] = React2.useState(null);
+  const fetchPrices = React2.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(",")]);
+  React2.useEffect(() => {
+    fetchPrices();
+  }, [fetchPrices]);
+  React2.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 = React2.useCallback(async () => {
+    await Promise.all([
+      strategiesResult.refresh(),
+      ordersResult.refresh(),
+      portfolioResult.refresh(),
+      marketResult.refresh()
+    ]);
+  }, [strategiesResult.refresh, ordersResult.refresh, portfolioResult.refresh, marketResult.refresh]);
+  const error = React2.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) {
@@ -5022,6 +5365,7 @@ exports.SupabaseService = SupabaseService;
 exports.TOKEN_NAMES = TOKEN_NAMES;
 exports.capitalize = capitalize;
 exports.checksumAddress = checksumAddress;
+exports.clearAITradingAccessToken = clearAITradingAccessToken;
 exports.createOneEngineClient = createOneEngineClient;
 exports.createSupabaseClient = createSupabaseClient;
 exports.fetchChains = fetchChains;
@@ -5050,10 +5394,17 @@ exports.omit = omit;
 exports.pick = pick;
 exports.priceService = priceService;
 exports.retry = retry;
+exports.setAITradingAccessToken = setAITradingAccessToken;
 exports.shortenAddress = shortenAddress;
 exports.sleep = sleep;
 exports.slugify = slugify;
 exports.truncate = truncate;
+exports.useAIMarketData = useAIMarketData;
+exports.useAIOrders = useAIOrders;
+exports.useAIPortfolio = useAIPortfolio;
+exports.useAIStrategies = useAIStrategies;
+exports.useAIStrategy = useAIStrategy;
+exports.useAITrading = useAITrading;
 exports.useOne = useOne;
 exports.useOneAuth = useOneAuth;
 exports.useOneEngine = useOneEngine;