@one_deploy/sdk 1.0.2 → 1.0.4

package/src/index.ts

@@ -157,6 +157,26 @@ export {
   useWalletBalance,
   useTokenPrice,
   useTokenPrices,
+  // AI Trading Hooks
+  useAIStrategies,
+  useAIStrategy,
+  useAIOrders,
+  useAIPortfolio,
+  useAIMarketData,
+  useAITrading,
+  setAITradingAccessToken,
+  clearAITradingAccessToken,
+} from './hooks';
+
+export type {
+  UseAIStrategiesOptions,
+  UseAIStrategiesResult,
+  UseAIStrategyResult,
+  UseAIOrdersOptions,
+  UseAIOrdersResult,
+  UseAIPortfolioResult,
+  UseAIMarketDataResult,
+  UseAITradingResult,
 } from './hooks';
 
 // ===== Utilities =====

package/src/react-native.ts

@@ -67,6 +67,29 @@ export {
   isOneSDKError,
 } from './utils';
 
+// ===== AI Trading Components =====
+// React Native components for AI trading integration
+export {
+  OneChainSelector,
+  CHAIN_CONFIG,
+} from './components/ai/OneChainSelector';
+export type { OneChainSelectorProps } from './components/ai/OneChainSelector';
+
+export { OneTierSelector } from './components/ai/OneTierSelector';
+export type { OneTierSelectorProps, Tier } from './components/ai/OneTierSelector';
+
+export {
+  OneCycleSelector,
+  DEFAULT_SHARE_RATES,
+} from './components/ai/OneCycleSelector';
+export type { OneCycleSelectorProps } from './components/ai/OneCycleSelector';
+
+export {
+  OnePairSelector,
+  PAIR_ICONS,
+} from './components/ai/OnePairSelector';
+export type { OnePairSelectorProps } from './components/ai/OnePairSelector';
+
 // ===== React Native Specific Utilities =====
 
 /**

package/src/services/engine.ts

@@ -1597,6 +1597,93 @@ export class OneEngineClient {
     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?: {
+    includeInactive?: boolean;
+    agentId?: string;
+  }): Promise<ApiResponse<{
+    agents?: Array<{
+      id: string;
+      name: string;
+      name_zh: string;
+      description: string;
+      description_zh: string;
+      category: string;
+      risk_level: number;
+      icon: string;
+      color: string;
+      tiers: Array<{ tier: number; amount: number; label: string; label_zh: string }>;
+      supported_cycles: number[];
+      default_cycle: number;
+      supported_pairs: string[];
+      supported_chains: string[];
+      is_active: boolean;
+      preview: {
+        tier: { tier: number; amount: number; label: string };
+        cycle: number;
+        dailyLots: number;
+        stabilityScore: number;
+        roiRange: { min: number; max: number; userMin: number; userMax: number };
+        shareRate: number;
+        profitEstimate: { monthlyMin: number; monthlyMax: number; cycleMin: number; cycleMax: number };
+      };
+    }>;
+    agent?: any;
+    shareRates?: Record<number, number>;
+  }>> {
+    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: {
+    agentId: string;
+    amount: number;
+    cycleDays: number;
+  }): Promise<ApiResponse<{
+    dailyLots: number;
+    effectiveCapital: number;
+    stabilityScore: number;
+    roiRange: { min: number; max: number; userMin: number; userMax: number };
+    shareRate: number;
+    profitEstimate: { monthlyMin: number; monthlyMax: number; cycleMin: number; cycleMax: number };
+  }>> {
+    return this.request('/api/v1/agents/calculate', {
+      method: 'POST',
+      body: JSON.stringify(params),
+    });
+  }
+
+  /**
+   * Get supported trading pairs from agents
+   */
+  async getTradingPairs(): Promise<ApiResponse<{
+    pairs: string[];
+    byAgent: Record<string, string[]>;
+  }>> {
+    const result = await this.getAgentConfigs();
+    if (result.success && result.data?.agents) {
+      const allPairs = new Set<string>();
+      const byAgent: Record<string, string[]> = {};
+      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 ==========
 
   /**
@@ -1842,6 +1929,103 @@ export class OneEngineClient {
   }>> {
     return this.request('/api/v1/prices?type=overview', { method: 'GET' });
   }
+
+  // ========== Project Management ==========
+
+  /**
+   * Get user's projects
+   */
+  async getProjects(options?: {
+    isActive?: boolean;
+  }): Promise<ApiResponse<{ projects: AdminProject[]; total: number }>> {
+    const params = new URLSearchParams();
+    if (options?.isActive !== undefined) 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: {
+    name: string;
+    slug: string;
+    settings?: Record<string, unknown>;
+  }): Promise<ApiResponse<{ project: AdminProject }>> {
+    return this.request('/api/v1/projects', {
+      method: 'POST',
+      body: JSON.stringify(params),
+    });
+  }
+
+  /**
+   * Get project details
+   */
+  async getProject(projectId: string): Promise<ApiResponse<{ project: AdminProject }>> {
+    return this.request(`/api/v1/projects/${projectId}`, { method: 'GET' });
+  }
+
+  /**
+   * Update project settings
+   */
+  async updateProject(projectId: string, updates: {
+    name?: string;
+    isActive?: boolean;
+    settings?: Record<string, unknown>;
+  }): Promise<ApiResponse<{ project: AdminProject }>> {
+    return this.request(`/api/v1/projects/${projectId}`, {
+      method: 'PATCH',
+      body: JSON.stringify(updates),
+    });
+  }
+
+  /**
+   * Get project features status
+   */
+  async getProjectFeatures(projectId: string): Promise<ApiResponse<{
+    features: Record<string, {
+      enabled: boolean;
+      name: string;
+      description: string;
+      description_zh: string;
+    }>;
+    availableFeatures: string[];
+  }>> {
+    return this.request(`/api/v1/projects/${projectId}/features`, { method: 'GET' });
+  }
+
+  /**
+   * Enable/disable features for a project
+   */
+  async updateProjectFeatures(projectId: string, features: {
+    wallet?: boolean;
+    swap?: boolean;
+    contracts?: boolean;
+    fiat?: boolean;
+    payments?: boolean;
+    quant?: boolean;
+    ai?: boolean;
+    x402?: boolean;
+  }): Promise<ApiResponse<{ project: AdminProject; message: string }>> {
+    return this.request(`/api/v1/projects/${projectId}/features`, {
+      method: 'PATCH',
+      body: JSON.stringify(features),
+    });
+  }
+
+  /**
+   * Regenerate project API key
+   */
+  async regenerateProjectApiKey(projectId: string): Promise<ApiResponse<{ apiKey: string }>> {
+    return this.request(`/api/v1/projects/${projectId}/api-key`, { method: 'POST' });
+  }
+
+  /**
+   * Delete project
+   */
+  async deleteProject(projectId: string): Promise<ApiResponse<{ deleted: boolean }>> {
+    return this.request(`/api/v1/projects/${projectId}`, { method: 'DELETE' });
+  }
 }
 
 // Factory function

package/src/services/index.ts

@@ -28,3 +28,19 @@ export { SupabaseService, createSupabaseClient, getSupabaseClient } from './supa
 
 // ===== Price Service (fallback for offline/cache) =====
 export { PriceService, priceService } from './price';
+
+// ===== Usage Tracking Service =====
+export {
+  UsageService,
+  getUsageService,
+  createUsageService,
+} from './usage';
+
+export type {
+  UsageCategory,
+  DisplayCategory,
+  UsageRecord,
+  UsageSummary,
+  UsageActivity,
+  UsageResponse,
+} from './usage';

package/src/services/usage.ts

@@ -0,0 +1,249 @@
+/**
+ * Usage Tracking Service
+ * Tracks AI usage for Personal Assistant and Trading Agent
+ */
+
+import { getConfig } from '../config';
+
+// Usage categories (internal)
+export type UsageCategory =
+  | 'wallet'
+  | 'payment'
+  | 'exchange_onramper'
+  | 'exchange_swap'
+  | 'ai_thirdweb'
+  | 'ai_trading_engine';
+
+// Display categories (client-facing)
+export type DisplayCategory = 'personal_assistant' | 'trading_agent';
+
+export interface UsageRecord {
+  userId: string;
+  category: UsageCategory;
+  action: string;
+  requestTokens?: number;
+  responseTokens?: number;
+  creditsUsed?: number;
+  metadata?: Record<string, any>;
+}
+
+export interface UsageSummary {
+  personal_assistant: {
+    requestCount: number;
+    totalTokens: number;
+    totalCredits: number;
+  };
+  trading_agent: {
+    requestCount: number;
+    totalTokens: number;
+    totalCredits: number;
+  };
+}
+
+export interface UsageActivity {
+  type: DisplayCategory;
+  action: string;
+  tokens: number;
+  credits: number;
+  timestamp: string;
+}
+
+export interface UsageResponse {
+  summary: UsageSummary;
+  dailyBreakdown: Array<{
+    date: string;
+    personal_assistant: number;
+    trading_agent: number;
+  }>;
+  recentActivity: UsageActivity[];
+  period: {
+    days: number;
+    startDate: string;
+    endDate: string;
+  };
+}
+
+/**
+ * Usage Tracking Service
+ */
+export class UsageService {
+  private baseUrl: string;
+  private userId: string | null = null;
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || getConfig().oneEngineUrl || '';
+  }
+
+  /**
+   * Set the current user ID for tracking
+   */
+  setUserId(userId: string): void {
+    this.userId = userId;
+  }
+
+  /**
+   * Record Personal Assistant usage (Thirdweb AI)
+   */
+  async trackPersonalAssistant(
+    action: string,
+    tokens?: { request?: number; response?: number },
+    credits?: number,
+    metadata?: Record<string, any>
+  ): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'ai_thirdweb',
+      action,
+      requestTokens: tokens?.request,
+      responseTokens: tokens?.response,
+      creditsUsed: credits,
+      metadata,
+    });
+  }
+
+  /**
+   * Record Trading Agent usage (Engine AI)
+   */
+  async trackTradingAgent(
+    action: string,
+    credits?: number,
+    metadata?: Record<string, any>
+  ): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'ai_trading_engine',
+      action,
+      creditsUsed: credits,
+      metadata,
+    });
+  }
+
+  /**
+   * Record wallet operation usage
+   */
+  async trackWallet(action: string, metadata?: Record<string, any>): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'wallet',
+      action,
+      metadata,
+    });
+  }
+
+  /**
+   * Record payment usage
+   */
+  async trackPayment(action: string, metadata?: Record<string, any>): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'payment',
+      action,
+      metadata,
+    });
+  }
+
+  /**
+   * Record exchange usage (onramper)
+   */
+  async trackOnramper(action: string, metadata?: Record<string, any>): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'exchange_onramper',
+      action,
+      metadata,
+    });
+  }
+
+  /**
+   * Record exchange usage (swap)
+   */
+  async trackSwap(action: string, metadata?: Record<string, any>): Promise<boolean> {
+    return this.recordUsage({
+      userId: this.userId!,
+      category: 'exchange_swap',
+      action,
+      metadata,
+    });
+  }
+
+  /**
+   * Record any usage
+   */
+  async recordUsage(record: UsageRecord): Promise<boolean> {
+    if (!record.userId) {
+      console.warn('[UsageService] No userId set, skipping usage tracking');
+      return false;
+    }
+
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/usage/user`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          userId: record.userId,
+          category: record.category,
+          action: record.action,
+          requestTokens: record.requestTokens || 0,
+          responseTokens: record.responseTokens || 0,
+          creditsUsed: record.creditsUsed || 0,
+          metadata: record.metadata || {},
+        }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error('[UsageService] Failed to record usage:', error);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('[UsageService] Error recording usage:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get AI usage summary for current user
+   */
+  async getAIUsage(days: number = 30): Promise<UsageResponse | null> {
+    if (!this.userId) {
+      console.warn('[UsageService] No userId set');
+      return null;
+    }
+
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/usage/user?userId=${this.userId}&days=${days}`
+      );
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error('[UsageService] Failed to get usage:', error);
+        return null;
+      }
+
+      const result = await response.json();
+      return result.data;
+    } catch (error) {
+      console.error('[UsageService] Error getting usage:', error);
+      return null;
+    }
+  }
+}
+
+// Singleton instance
+let usageServiceInstance: UsageService | null = null;
+
+export function getUsageService(): UsageService {
+  if (!usageServiceInstance) {
+    usageServiceInstance = new UsageService();
+  }
+  return usageServiceInstance;
+}
+
+export function createUsageService(baseUrl?: string): UsageService {
+  return new UsageService(baseUrl);
+}

package/dist/config/index.d.mts

@@ -1,74 +0,0 @@
-import { ChainConfig } from '../types/index.mjs';
-
-/**
- * ONE SDK Configuration
- *
- * Chain data is fetched from ONE Engine API - no duplicates needed here.
- * Engine is the single source of truth for 200+ EVM chains.
- */
-
-interface OneConfig {
-    oneEngineUrl: string;
-    oneClientId: string;
-    oneSecretKey?: string;
-    supabaseUrl?: string;
-    supabaseAnonKey?: string;
-    thirdwebClientId?: string;
-}
-declare function initOneSDK(options: Partial<OneConfig>): void;
-declare function getConfig(): OneConfig;
-declare function isInitialized(): boolean;
-declare function getEngineUrl(): string;
-/**
- * Fetch chains from ONE Engine API
- * Engine is the source of truth for 200+ EVM chains
- */
-declare function fetchChains(options?: {
-    category?: 'mainnet' | 'l2' | 'testnet' | 'gaming' | 'recommended';
-    smartWallet?: boolean;
-    limit?: number;
-}): Promise<ChainConfig[]>;
-/**
- * Get all supported chains (cached)
- */
-declare function getChains(): Promise<ChainConfig[]>;
-/**
- * Get chain by ID
- */
-declare function getChainById(chainId: number): Promise<ChainConfig | undefined>;
-/**
- * Get chain by name/shortName
- */
-declare function getChainByName(name: string): Promise<ChainConfig | undefined>;
-/**
- * Get recommended chains for UI display
- */
-declare function getRecommendedChains(): Promise<ChainConfig[]>;
-/**
- * Get chains with smart wallet support
- */
-declare function getSmartWalletChains(): Promise<ChainConfig[]>;
-declare const CHAIN_IDS: {
-    readonly ETHEREUM: 1;
-    readonly POLYGON: 137;
-    readonly BSC: 56;
-    readonly ARBITRUM: 42161;
-    readonly OPTIMISM: 10;
-    readonly BASE: 8453;
-    readonly AVALANCHE: 43114;
-    readonly ZKSYNC: 324;
-    readonly LINEA: 59144;
-    readonly SCROLL: 534352;
-    readonly BLAST: 81457;
-    readonly SEPOLIA: 11155111;
-    readonly BASE_SEPOLIA: 84532;
-    readonly ARBITRUM_SEPOLIA: 421614;
-};
-declare const DEFAULT_CHAIN_ID: 8453;
-declare const TOKEN_NAMES: Record<string, string>;
-declare const COINGECKO_IDS: Record<string, string>;
-declare const CHAIN_CONFIGS: Record<string, ChainConfig>;
-declare const SUPPORTED_CHAINS: string[];
-declare function getChainConfig(chain: string): ChainConfig | undefined;
-
-export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, type OneConfig, SUPPORTED_CHAINS, TOKEN_NAMES, fetchChains, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized };

package/dist/config/index.d.ts

@@ -1,74 +0,0 @@
-import { ChainConfig } from '../types/index.js';
-
-/**
- * ONE SDK Configuration
- *
- * Chain data is fetched from ONE Engine API - no duplicates needed here.
- * Engine is the single source of truth for 200+ EVM chains.
- */
-
-interface OneConfig {
-    oneEngineUrl: string;
-    oneClientId: string;
-    oneSecretKey?: string;
-    supabaseUrl?: string;
-    supabaseAnonKey?: string;
-    thirdwebClientId?: string;
-}
-declare function initOneSDK(options: Partial<OneConfig>): void;
-declare function getConfig(): OneConfig;
-declare function isInitialized(): boolean;
-declare function getEngineUrl(): string;
-/**
- * Fetch chains from ONE Engine API
- * Engine is the source of truth for 200+ EVM chains
- */
-declare function fetchChains(options?: {
-    category?: 'mainnet' | 'l2' | 'testnet' | 'gaming' | 'recommended';
-    smartWallet?: boolean;
-    limit?: number;
-}): Promise<ChainConfig[]>;
-/**
- * Get all supported chains (cached)
- */
-declare function getChains(): Promise<ChainConfig[]>;
-/**
- * Get chain by ID
- */
-declare function getChainById(chainId: number): Promise<ChainConfig | undefined>;
-/**
- * Get chain by name/shortName
- */
-declare function getChainByName(name: string): Promise<ChainConfig | undefined>;
-/**
- * Get recommended chains for UI display
- */
-declare function getRecommendedChains(): Promise<ChainConfig[]>;
-/**
- * Get chains with smart wallet support
- */
-declare function getSmartWalletChains(): Promise<ChainConfig[]>;
-declare const CHAIN_IDS: {
-    readonly ETHEREUM: 1;
-    readonly POLYGON: 137;
-    readonly BSC: 56;
-    readonly ARBITRUM: 42161;
-    readonly OPTIMISM: 10;
-    readonly BASE: 8453;
-    readonly AVALANCHE: 43114;
-    readonly ZKSYNC: 324;
-    readonly LINEA: 59144;
-    readonly SCROLL: 534352;
-    readonly BLAST: 81457;
-    readonly SEPOLIA: 11155111;
-    readonly BASE_SEPOLIA: 84532;
-    readonly ARBITRUM_SEPOLIA: 421614;
-};
-declare const DEFAULT_CHAIN_ID: 8453;
-declare const TOKEN_NAMES: Record<string, string>;
-declare const COINGECKO_IDS: Record<string, string>;
-declare const CHAIN_CONFIGS: Record<string, ChainConfig>;
-declare const SUPPORTED_CHAINS: string[];
-declare function getChainConfig(chain: string): ChainConfig | undefined;
-
-export { CHAIN_CONFIGS, CHAIN_IDS, COINGECKO_IDS, DEFAULT_CHAIN_ID, type OneConfig, SUPPORTED_CHAINS, TOKEN_NAMES, fetchChains, getChainById, getChainByName, getChainConfig, getChains, getConfig, getEngineUrl, getRecommendedChains, getSmartWalletChains, initOneSDK, isInitialized };