@strkfarm/sdk 2.0.0-dev.26 → 2.0.0-dev.28

package/src/interfaces/common.tsx

@@ -55,6 +55,68 @@ export interface IProtocol {
   logo: string;
 }
 
+export enum StrategyTag {
+  META_VAULT = "Meta Vaults",
+  LEVERED = "Maxx",
+  AUTOMATED_LP = "Ekubo",
+  BTC = "BTC"
+}
+
+export enum VaultType {
+  LOOPING = "Looping",
+  META_VAULT = "Meta Vault",
+  DELTA_NEUTRAL = "Delta Neutral",
+  AUTOMATED_LP = "Automated LP",
+}
+
+// Security metadata enums
+export enum AuditStatus {
+  AUDITED = "Audited",
+  NOT_AUDITED = "Not Audited",
+}
+
+export enum SourceCodeType {
+  OPEN_SOURCE = "Open Source",
+  CLOSED_SOURCE = "Closed Source",
+}
+
+export enum AccessControlType {
+  MULTISIG_ACCOUNT = "Multisig Account",
+  STANDARD_ACCOUNT = "Standard Account",
+}
+
+export enum InstantWithdrawalVault {
+  YES = "Yes",
+  NO = "No",
+}
+
+// Security metadata interfaces
+export interface SourceCodeInfo {
+  type: SourceCodeType;
+  contractLink: string;
+}
+
+export interface AccessControlInfo {
+  type: AccessControlType;
+  addresses: ContractAddr[];
+  timeLock: string;
+}
+
+export interface SecurityMetadata {
+  auditStatus: AuditStatus;
+  sourceCode: SourceCodeInfo;
+  accessControl: AccessControlInfo;
+}
+
+export interface RedemptionInfo {
+  instantWithdrawalVault: InstantWithdrawalVault;
+  redemptionsInfo: {
+    title: string; // e.g. Upto $1M
+    description: string; // e.g. "1-2 hours"
+  }[],
+  alerts: StrategyAlert[];
+}
+
 export enum FlowChartColors {
   Green = "purple",
   Blue = "#35484f",
@@ -66,26 +128,65 @@ export interface FAQ {
   answer: string | React.ReactNode;
 }
 
+export enum StrategyLiveStatus {
+    ACTIVE = "Active",
+    NEW = "New",
+    COMING_SOON = "Coming Soon",
+    DEPRECATED = "Deprecated", // active but not recommended
+    RETIRED = "Retired", // not active anymore
+    HOT = "Hot & New 🔥"
+}
+
+export interface StrategyAlert {
+    type: "warning" | "info";
+    text: string | React.ReactNode;
+    tab: "all" | "deposit" | "withdraw";
+}
+
+export interface StrategySettings {
+    maxTVL?: Web3Number;
+    liveStatus?: StrategyLiveStatus;
+    isPaused?: boolean;
+    isInMaintenance?: boolean;
+    isAudited: boolean;
+    isInstantWithdrawal?: boolean;
+    hideHarvestInfo?: boolean;
+    is_promoted?: boolean;
+    isTransactionHistDisabled?: boolean;
+    quoteToken: TokenInfo;
+    hideNetEarnings?: boolean;
+    showWithdrawalWarningModal?: boolean;
+    alerts?: StrategyAlert[];
+    tags?: StrategyTag[];
+}
+
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
+ * @property security - Security-related metadata including audit status, source code information, and access control details.
+ * @property redemptionInfo - Redemption information including instant withdrawal availability and expected redemption times.
  */
 export interface IStrategyMetadata<T> {
+  id: string;
   name: string;
   description: string | React.ReactNode;
   address: ContractAddr;
   launchBlock: number;
   type: "ERC4626" | "ERC721" | "Other";
+  vaultType: {
+    type: VaultType;
+    description: string;
+  };
   depositTokens: TokenInfo[];
   protocols: IProtocol[];
   auditUrl?: string;
-  maxTVL: Web3Number;
   risk: {
     riskFactor: RiskFactor[];
     netRisk: number;
     notARisks: RiskType[];
   };
   apyMethodology?: string;
+  realizedAPYMethodology?: string;
   additionalInfo: T;
   contractDetails: {
     address: ContractAddr;
@@ -97,7 +198,30 @@ export interface IStrategyMetadata<T> {
   docs?: string;
   investmentSteps: string[];
   curator?: { name: string, logo: string },
-  isPreview?: boolean
+  isPreview?: boolean;
+  tags?: StrategyTag[];
+  security: SecurityMetadata;
+  redemptionInfo: RedemptionInfo;
+  usualTimeToEarnings: null | string; // e.g. "2 weeks" // some strats grow like step functions
+  usualTimeToEarningsDescription: null | string; // e.g. "LSTs price on DEX goes up roughly every 2 weeks"
+  discontinuationInfo?: {
+    date?: Date;
+    reason?: React.ReactNode | string;
+    info?: React.ReactNode | string;
+  };
+  settings?: StrategySettings;
+    // Legacy field for multi-step strategies (deprecated, use investmentFlows instead)
+    actions?: Array<{
+        name?: string;
+        pool?: {
+            protocol?: { name: string; logo: string };
+            pool?: { name: string; logos?: string[] };
+            apr?: number;
+            borrow?: { apr?: number };
+        };
+        amount?: string | number;
+        isDeposit?: boolean;
+    }>;
 }
 
 export interface IInvestmentFlow {
@@ -124,6 +248,23 @@ export function getMainnetConfig(
   };
 }
 
+export const getStrategyTagDesciption = (tag: StrategyTag): string => {
+  switch (tag) {
+    case StrategyTag.META_VAULT:
+      return "A meta vault is a vault that auto allocates funds to multiple vaults based on optimal yield opportunities";
+    case StrategyTag.LEVERED:
+      return "Looping vaults on Endur LSTs with leveraged borrowing of STRK or BTC to increase yield (2-4x higher yield than simply staking)";
+    case StrategyTag.AUTOMATED_LP:
+      return "Automated LP vaults on Ekubo that rebalance position automatically, ensuring you earn fees efficiently";
+    case StrategyTag.BTC:
+      return "BTC linked vaults";
+  }
+}
+
+export const getAllStrategyTags = (): StrategyTag[] => {
+  return Object.values(StrategyTag);
+}
+
 export const getRiskExplaination = (riskType: RiskType) => {
   switch (riskType) {
     case RiskType.MARKET_RISK:
@@ -215,6 +356,30 @@ export interface VaultPosition {
   protocol: IProtocol
 }
 
+export interface AmountInfo {
+    amount: Web3Number;
+    usdValue: number;
+    tokenInfo: TokenInfo;
+}
+
+export interface AmountsInfo {
+    usdValue: number;
+    amounts: AmountInfo[];
+}
+
+/**
+ * Strategy capabilities interface
+ * Describes what optional methods a strategy instance supports
+ */
+export interface StrategyCapabilities {
+    hasMatchInputAmounts: boolean;
+    hasNetAPY: boolean;
+    hasGetInvestmentFlows: boolean;
+    hasGetPendingRewards: boolean;
+    hasHarvest: boolean;
+    hasRebalance: boolean;
+}
+
 const VesuProtocol: IProtocol = {
   name: "Vesu",
   logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"

package/src/modules/ExtendedWrapperSDk/types.ts

@@ -79,9 +79,10 @@ export enum AssetOperationType {
 }
 
 export enum AssetOperationStatus {
-  PENDING = "PENDING",
+  CREATED = "CREATED",
+  IN_PROGRESS = "IN_PROGRESS",
   COMPLETED = "COMPLETED",
-  FAILED = "FAILED",
+  REJECTED = "REJECTED",
 }
 
 // Base types
@@ -293,7 +294,8 @@ export interface ExtendedApiResponse<T> {
 
 // Configuration types
 export interface ExtendedWrapperConfig {
-  baseUrl: string;
+  readUrl: string;
+  writeUrl: string;
   apiKey?: string;
   timeout?: number;
   retries?: number;
@@ -308,4 +310,24 @@ export interface FundingRate {
  m: string;
  f:string;
  t:number;
-}
+}
+
+export interface FundingPayment {
+  id: number;
+  accountId?: number;
+  account_id?: number;
+  market: string;
+  positionId?: number;
+  position_id?: number;
+  side: PositionSide;
+  size: string;
+  value: string;
+  markPrice?: string;
+  mark_price?: string;
+  fundingFee?: string;
+  funding_fee?: string;
+  fundingRate?: string;
+  funding_rate?: string;
+  paidTime?: number;
+  paid_time?: number;
+}

package/src/modules/ExtendedWrapperSDk/wrapper.ts

@@ -22,20 +22,23 @@ import {
   AssetOperationType,
   AssetOperationStatus,
   FundingRate,
+  FundingPayment,
   UpdateLeverageRequest,
 } from "./types";
 
 export class ExtendedWrapper {
-  private baseUrl: string;
+  private readUrl: string;
+  private writeUrl: string;
   private apiKey?: string;
   private timeout: number;
   private retries: number;
 
   constructor(config: ExtendedWrapperConfig) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
     this.apiKey = config.apiKey;
     this.timeout = config.timeout || 30000; // 30 seconds default
     this.retries = config.retries || 3;
+    this.readUrl = config.readUrl.replace(/\/$/, "");
+    this.writeUrl = config.writeUrl.replace(/\/$/, "");
   }
 
   /**
@@ -43,15 +46,14 @@ export class ExtendedWrapper {
    */
   private async makeRequest<T>(
     endpoint: string,
-    options: RequestInit = {}
+    isRead: boolean,
+    options: RequestInit = {},
   ): Promise<ExtendedApiResponse<T>> {
-    const url = `${this.baseUrl}${endpoint}`;
-
+    const url = `${isRead ? this.readUrl : this.writeUrl}${endpoint}`;
     const headers: Record<string, any> = {
       "Content-Type": "application/json",
       ...options.headers,
     };
-
     if (this.apiKey) {
       headers["X-API-Key"] = this.apiKey;
     }
@@ -73,36 +75,42 @@ export class ExtendedWrapper {
           throw new Error(
             `HTTP ${response.status}: ${
               errorData.detail || response.statusText
-            }`
+            }`,
           );
         }
-        
+
         const text = await response.text();
 
         // Replace large integers (greater than MAX_SAFE_INTEGER) with quoted strings
         // This regex finds numbers that are likely to be large integers in the "data" field
-        const MAX_SAFE_INTEGER_STR = '9007199254740991';
+        const MAX_SAFE_INTEGER_STR = "9007199254740991";
         const largeIntegerRegex = /"data"\s*:\s*(\d{16,})/g;
-      
-        const modifiedText = text.replace(largeIntegerRegex, (match, largeInt) => {
-          // Compare as strings to avoid precision loss
-          if (largeInt.length > MAX_SAFE_INTEGER_STR.length || 
-              (largeInt.length === MAX_SAFE_INTEGER_STR.length && largeInt > MAX_SAFE_INTEGER_STR)) {
-            // Replace the number with a quoted string to preserve precision
-            return `"data":"${largeInt}"`;
-          }
-          return match; // Keep original if it's a safe integer
-        });
-        
+
+        const modifiedText = text.replace(
+          largeIntegerRegex,
+          (match, largeInt) => {
+            // Compare as strings to avoid precision loss
+            if (
+              largeInt.length > MAX_SAFE_INTEGER_STR.length ||
+              (largeInt.length === MAX_SAFE_INTEGER_STR.length &&
+                largeInt > MAX_SAFE_INTEGER_STR)
+            ) {
+              // Replace the number with a quoted string to preserve precision
+              return `"data":"${largeInt}"`;
+            }
+            return match; // Keep original if it's a safe integer
+          },
+        );
+
         const data = JSON.parse(modifiedText);
-        
-        if (data && typeof data.data === 'string' && /^\d+$/.test(data.data)) {
+
+        if (data && typeof data.data === "string" && /^\d+$/.test(data.data)) {
           const numValue = Number(data.data);
           if (Number.isSafeInteger(numValue)) {
             data.data = numValue;
           }
         }
-        
+
         return data;
       } catch (error) {
         lastError = error as Error;
@@ -122,9 +130,9 @@ export class ExtendedWrapper {
    * Create a new order on Extended Exchange
    */
   async createOrder(
-    request: CreateOrderRequest
+    request: CreateOrderRequest,
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
-    return this.makeRequest<PlacedOrder>("/api/v1/orders", {
+    return this.makeRequest<PlacedOrder>("/api/v1/orders", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -134,32 +142,35 @@ export class ExtendedWrapper {
    * Get all markets
    */
   async getMarkets(
-    marketNames?: string
+    marketNames?: string,
   ): Promise<ExtendedApiResponse<Market[]>> {
     const params = marketNames
       ? `?market_names=${encodeURIComponent(marketNames)}`
       : "";
-    return this.makeRequest<Market[]>(`/api/v1/markets${params}`);
+    return this.makeRequest<Market[]>(`/api/v1/markets${params}`, false);
   }
 
-   /**
-   * 
+  /**
+   *
    * @param orderId - The ID of the order to get
    * @returns The order
    */
-   async getOrderByOrderId(orderId: string): Promise<ExtendedApiResponse<OpenOrder>> {
+  async getOrderByOrderId(
+    orderId: string,
+  ): Promise<ExtendedApiResponse<OpenOrder>> {
     const orderIdInt = parseInt(orderId);
-    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderIdInt}`);
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderIdInt}`, false);
   }
 
   /**
    * Get market statistics for a specific market
    */
   async getMarketStatistics(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<MarketStats>> {
     return this.makeRequest<MarketStats>(
-      `/api/v1/markets/statistics?market_name=${encodeURIComponent(marketName)}`
+      `/api/v1/markets/statistics?market_name=${encodeURIComponent(marketName)}`,
+      false,
     );
   }
 
@@ -167,19 +178,20 @@ export class ExtendedWrapper {
    * Get current trading positions
    */
   async getPositions(
-    marketNames?: string
+    marketNames?: string,
   ): Promise<ExtendedApiResponse<Position[]>> {
     const params = marketNames
       ? `?market_names=${encodeURIComponent(marketNames)}`
       : "";
-    return this.makeRequest<Position[]>(`/api/v1/positions${params}`);
+    const response = await this.makeRequest<Position[]>(`/api/v1/positions${params}`, true);
+    return response;
   }
 
   /**
    * Get account balance and holdings
    */
   async getHoldings(): Promise<ExtendedApiResponse<Balance>> {
-    return this.makeRequest<Balance>("/api/v1/holdings");
+    return this.makeRequest<Balance>("/api/v1/holdings", true);
   }
 
   /**
@@ -187,9 +199,9 @@ export class ExtendedWrapper {
    * Returns data as number | string to preserve precision for large integers
    */
   async withdraw(
-    request: WithdrawRequest
+    request: WithdrawRequest,
   ): Promise<ExtendedApiResponse<number | string>> {
-    return this.makeRequest<number | string>("/api/v1/withdraw", {
+    return this.makeRequest<number | string>("/api/v1/withdraw", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -207,7 +219,7 @@ export class ExtendedWrapper {
       };
     }>
   > {
-    return this.makeRequest("/api/v1/withdraw/sign", {
+    return this.makeRequest("/api/v1/withdraw/sign", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -217,25 +229,24 @@ export class ExtendedWrapper {
    * Cancel an existing order
    */
   async cancelOrder(
-    request: CancelOrderRequest
+    request: CancelOrderRequest,
   ): Promise<ExtendedApiResponse<{}>> {
-    return this.makeRequest<{}>("/api/v1/orders/cancel", {
+    return this.makeRequest<{}>("/api/v1/orders/cancel", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
   }
 
-
   /**
    * Get all open orders
    */
   async getOpenOrders(
-    marketName?: string
+    marketName?: string,
   ): Promise<ExtendedApiResponse<OpenOrder[]>> {
     const endpoint = marketName
       ? `/api/v1/marketOrders/${marketName}`
       : "/api/v1/marketOrders";
-    return this.makeRequest<OpenOrder[]>(endpoint,{
+    return this.makeRequest<OpenOrder[]>(endpoint, false, {
       method: "GET",
       headers: {
         "Content-Type": "application/json",
@@ -249,9 +260,9 @@ export class ExtendedWrapper {
    * @returns
    */
   async updateLeverage(
-    request: UpdateLeverageRequest
+    request: UpdateLeverageRequest,
   ): Promise<ExtendedApiResponse<{}>> {
-    return this.makeRequest<{}>("/api/v1/leverage", {
+    return this.makeRequest<{}>("/api/v1/leverage", false, {
       method: "POST",
       body: JSON.stringify(request),
     });
@@ -269,7 +280,7 @@ export class ExtendedWrapper {
       endTime?: number;
       cursor?: number;
       limit?: number;
-    } = {}
+    } = {},
   ): Promise<ExtendedApiResponse<AssetOperation[]>> {
     const params = new URLSearchParams();
 
@@ -294,14 +305,14 @@ export class ExtendedWrapper {
       queryString ? `?${queryString}` : ""
     }`;
 
-    return this.makeRequest<AssetOperation[]>(endpoint);
+    return this.makeRequest<AssetOperation[]>(endpoint, false);
   }
 
   /**
    * Health check endpoint
    */
   async healthCheck(): Promise<ExtendedApiResponse<MarketStats>> {
-    return this.makeRequest<MarketStats>("/api/v1/health");
+    return this.makeRequest<MarketStats>("/api/v1/health", false);
   }
 
   /**
@@ -313,10 +324,11 @@ export class ExtendedWrapper {
     price: string,
     options: {
       postOnly?: boolean;
+      reduceOnly?: boolean;
       previousOrderId?: number;
       externalId?: string;
       timeInForce?: TimeInForce;
-    } = {}
+    } = {},
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
     return this.createOrder({
       market_name: marketName,
@@ -327,13 +339,13 @@ export class ExtendedWrapper {
     });
   }
 
-   /**
+  /**
    * Get order by ID
    * @param orderId - The ID of the order to get
    * @returns The order
    */
-   async getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>> {
-    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderId}`);
+  async getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>> {
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderId}`, false);
   }
 
   /**
@@ -345,10 +357,11 @@ export class ExtendedWrapper {
     price: string,
     options: {
       postOnly?: boolean;
+      reduceOnly?: boolean;
       previousOrderId?: number;
       externalId?: string;
       timeInForce?: TimeInForce;
-    } = {}
+    } = {},
   ): Promise<ExtendedApiResponse<PlacedOrder>> {
     return this.createOrder({
       market_name: marketName,
@@ -363,7 +376,7 @@ export class ExtendedWrapper {
    * Get positions for a specific market
    */
   async getPositionsForMarket(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<Position[]>> {
     return this.getPositions(marketName);
   }
@@ -372,7 +385,7 @@ export class ExtendedWrapper {
    * Get open orders for a specific market
    */
   async getOpenOrdersForMarket(
-    marketName: string
+    marketName: string,
   ): Promise<ExtendedApiResponse<OpenOrder[]>> {
     return this.getOpenOrders(marketName);
   }
@@ -383,21 +396,25 @@ export class ExtendedWrapper {
   async cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>> {
     return this.cancelOrder({ order_id: orderId });
   }
-  
+
   /**
    * Get order history for a specific market
    * @param marketName - The name of the market to get order history for
    * @returns The order history for the specified market
    */
-  async getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>> {
-    return this.makeRequest<OpenOrder[]>(`/api/v1/marketOrders/${marketName}`);
+  async getOrderHistory(
+    marketName: string,
+  ): Promise<ExtendedApiResponse<OpenOrder[]>> {
+    return this.makeRequest<OpenOrder[]>(`/api/v1/marketOrders/${marketName}`, false);
   }
 
   /**
    * Withdraw USDC (convenience method)
    * Returns data as number | string to preserve precision for large integers
    */
-  async withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number | string>> {
+  async withdrawUSDC(
+    amount: string,
+  ): Promise<ExtendedApiResponse<number | string>> {
     return this.withdraw({ amount, asset: "USDC" });
   }
 
@@ -409,16 +426,42 @@ export class ExtendedWrapper {
   async getFundingRates(
     marketName: string,
     side: string,
-    startTime: number,
+    startTime?: number,
     endTime?: number,
-     // in epoch  milliseconds
+    // in epoch  milliseconds
   ): Promise<ExtendedApiResponse<FundingRate[]>> {
-    const endTimeParam = endTime !== undefined ? `&end_time=${endTime}` : '';
-    const startTimeParam = startTime !== undefined ? `&start_time=${startTime}` : '';
-    return this.makeRequest<FundingRate[]>(
+    const endTimeParam = endTime !== undefined ? `&end_time=${endTime}` : "";
+    const startTimeParam =
+      startTime !== undefined ? `&start_time=${startTime}` : "";
+    const response = await this.makeRequest<FundingRate[]>(
       `/api/v1/markets/funding-rates?market_name=${encodeURIComponent(
-        marketName
-      )}&side=${encodeURIComponent(side)}${startTimeParam}${endTimeParam}`
+        marketName,
+      )}&side=${encodeURIComponent(side)}${startTimeParam}${endTimeParam}`,
+      true
+    );
+    return response;
+  }
+
+  /**
+   * Get funding payments for a specific market.
+   */
+  async getUserFundingPayments(
+    marketName: string,
+    side: string,
+    startTime: number,
+    limit?: number,
+    cursor?: number,
+  ): Promise<ExtendedApiResponse<FundingPayment[]>> {
+    const params = new URLSearchParams();
+    params.append("start_time", String(startTime));
+    params.append("market_names", marketName);
+    params.append("side", side);
+    if (limit !== undefined) params.append("limit", String(limit));
+    if (cursor !== undefined) params.append("cursor", String(cursor));
+
+    return this.makeRequest<FundingPayment[]>(
+      `/api/v1/account/funding-payments?${params.toString()}`,
+      true,
     );
   }
 }