@strkfarm/sdk 1.2.1 → 2.0.0-dca.2

package/src/dataTypes/_bignumber.ts

@@ -1,5 +1,6 @@
 import { logger } from "@/utils/logger";
 import BigNumber from "bignumber.js";
+import { uint256 } from "starknet";
 
 export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   decimals: number;
@@ -107,6 +108,10 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
       sign: sign,
     }
   }
+
+  toUint256() {
+    return uint256.bnToUint256(this.toWei());
+  }
 }
 
 BigNumber.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN });

package/src/dataTypes/bignumber.browser.ts

@@ -1,3 +1,4 @@
+import { Uint256, uint256 } from "starknet";
 import { _Web3Number } from "./_bignumber";
 
 export class Web3Number extends _Web3Number<Web3Number> {
@@ -5,4 +6,8 @@ export class Web3Number extends _Web3Number<Web3Number> {
         const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
         return new Web3Number(bn.toString(), decimals);
     }
+
+    static fromUint256(uint256Value: Uint256): Web3Number {
+        return this.fromWei(uint256.uint256ToBN(uint256Value).toString(), 18);
+    }
 }

package/src/dataTypes/bignumber.node.ts

@@ -1,5 +1,6 @@
 import util from 'util';
 import { _Web3Number } from "./_bignumber";
+import { Uint256, uint256 } from 'starknet';
 
 export class Web3Number extends _Web3Number<Web3Number> {
 
@@ -8,6 +9,10 @@ export class Web3Number extends _Web3Number<Web3Number> {
         return new Web3Number(bn.toString(), decimals);
     }
 
+    static fromUint256(uint256Value: Uint256): Web3Number {
+        return this.fromWei(uint256.uint256ToBN(uint256Value).toString(), 18);
+    }
+
     [util.inspect.custom](depth: any, opts: any): string {
         return this.toString();
     }

package/src/dataTypes/index.ts

@@ -1,2 +1,3 @@
-export * from '@/dataTypes/bignumber';
-export * from './address';
+export * from "@/dataTypes/bignumber";
+export * from "./address";
+export * from "./mynumber";

package/src/dataTypes/mynumber.ts

@@ -0,0 +1,141 @@
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
+
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+BigNumber.config({
+    DECIMAL_PLACES: 18
+});
+
+export class MyNumber {
+    bigNumber: BigNumber;
+    decimals: number;
+
+    constructor(bigNumber: string, decimals: number) {
+        this.bigNumber = new BigNumber(bigNumber);
+        this.decimals = decimals;
+    }
+
+    static fromEther(num: string, decimals: number) {
+        try {
+            return new MyNumber(
+                Number(
+                    ethers.parseUnits(Number(num).toFixed(10), decimals)
+                ).toFixed(6),
+                decimals
+            );
+        } catch (e) {
+            console.error("fromEther", e, num, decimals);
+            throw e;
+        }
+    }
+
+    static fromZero() {
+        return new MyNumber("0", 0);
+    }
+
+    toString() {
+        return this.bigNumber.toFixed();
+    }
+
+    toEtherStr() {
+        return ethers.formatUnits(this.bigNumber.toFixed(), this.decimals);
+    }
+
+    toFixedStr(decimals: number) {
+        return Number(this.toEtherStr()).toFixed(decimals);
+    }
+
+    toEtherToFixedDecimals(decimals: number) {
+        // rounding down
+        if (this.bigNumber.isNaN()) {
+            return "NaN";
+        }
+        return (
+            Math.floor(parseFloat(this.toEtherStr()) * 10 ** decimals) /
+            10 ** decimals
+        ).toFixed(decimals);
+    }
+
+    isZero() {
+        return this.bigNumber.eq("0");
+    }
+
+    /**
+     *
+     * @param amountEther in token terms without decimal e.g. 1 for 1 STRK
+     * @param command BigNumber compare funds. e.g. gte, gt, lt
+     * @returns
+     * @dev Add more commands as needed
+     */
+    compare(amountEther: string, command: "gte" | "gt" | "lt") {
+        const fullNum = new BigNumber(
+            ethers.parseUnits(amountEther, this.decimals).toString()
+        );
+        return this.bigNumber[command](fullNum);
+    }
+
+    operate(command: "div" | "plus" | "mul", value: string | number) {
+        const bn = new BigNumber(Number(value).toFixed(6));
+        return new MyNumber(
+            this.bigNumber[command](bn).toFixed(0),
+            this.decimals
+        );
+    }
+
+    subtract(value: MyNumber) {
+        const bn = this.bigNumber.minus(value.bigNumber);
+        return new MyNumber(bn.toString(), this.decimals);
+    }
+
+    static min(a: MyNumber, b: MyNumber) {
+        if (a.decimals !== b.decimals) {
+            const diff = Math.abs(a.decimals - b.decimals);
+            if (a.decimals > b.decimals) {
+                b = new MyNumber(
+                    b.bigNumber.times(10 ** diff).toString(),
+                    a.decimals
+                );
+            } else {
+                a = new MyNumber(
+                    a.bigNumber.times(10 ** diff).toString(),
+                    b.decimals
+                );
+            }
+        }
+        const bn = BigNumber.min(a.bigNumber, b.bigNumber);
+        return new MyNumber(
+            bn.toString(),
+            a.decimals > b.decimals ? a.decimals : b.decimals
+        );
+    }
+
+    static max(a: MyNumber, b: MyNumber) {
+        if (a.decimals !== b.decimals) {
+            const diff = Math.abs(a.decimals - b.decimals);
+            if (a.decimals > b.decimals) {
+                b = new MyNumber(
+                    b.bigNumber.times(10 ** diff).toString(),
+                    a.decimals
+                );
+            } else {
+                a = new MyNumber(
+                    a.bigNumber.times(10 ** diff).toString(),
+                    b.decimals
+                );
+            }
+        }
+        const bn = BigNumber.max(a.bigNumber, b.bigNumber);
+        return new MyNumber(
+            bn.toString(),
+            a.decimals > b.decimals ? a.decimals : b.decimals
+        );
+    }
+
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
+        return JSON.stringify({
+            raw: this.toString(),
+            decimals: this.decimals
+        });
+    }
+}

package/src/global.ts

@@ -165,6 +165,33 @@ const defaultTokens: TokenInfo[] = [{
     coingeckId: undefined,
     displayDecimals: 2,
     priceCheckAmount: 100,
+}, {
+    name: "fyeWBTC",
+    symbol: "fyeWBTC",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/wbtc.svg',
+    address: ContractAddr.from('0x04dd39de0a588f5e1c7a8377e1bef2c49caaee49a11433429d2c48f587b3a492'),
+    decimals: 8,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
+}, {
+    name: "fyETH",
+    symbol: "fyETH",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/eth.svg',
+    address: ContractAddr.from('0x050707bC3b8730022F10530C2c6f6b9467644129C50C2868Ad0036c5e4E9e616'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 4,
+    priceCheckAmount: 0.1,
+}, {
+    name: "fyeUSDC",
+    symbol: "fyeUSDC",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/usdc.svg',
+    address: ContractAddr.from('0x07fdcec0cef01294c9c3d52415215949805c77bae8003702a7928fd6d2c36bc1'),
+    decimals: 6,
+    coingeckId: undefined,
+    displayDecimals: 2,
+    priceCheckAmount: 100,
 }]
 const tokens: TokenInfo[] = defaultTokens;
 
@@ -255,6 +282,21 @@ export class Global {
         return token;
     }
 
+    static async getTokenInfoFromName(tokenName: string) {
+        // if tokens are not loaded, load them
+        if (tokens.length == defaultTokens.length) {
+            await Global.getTokens();
+        }
+
+        const token = tokens.find(
+            (token) => token.name.toLowerCase() === tokenName.toLowerCase()
+        );
+        if (!token) {
+            throw new FatalError(`Token not found: ${tokenName}`);
+        }
+        return token;
+    }
+
     static setGlobalCache(key: string, data: any, ttl: number = 60000) {
         Global.cache[key] = {
             value: data,

package/src/index.browser.ts

@@ -3,4 +3,5 @@ export * from './modules';
 export * from './interfaces';
 export * from './dataTypes';
 export * from './global';
-export * from './strategies';
+export * from './strategies';
+export * from "./utils";

package/src/interfaces/common.tsx

@@ -55,6 +55,69 @@ 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",
+  Other = "Other",
+}
+
+// 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 +129,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 +199,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 +249,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:
@@ -214,6 +356,30 @@ export interface VaultPosition {
   remarks: string
 }
 
+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/apollo-client-config.ts

@@ -0,0 +1,28 @@
+import { ApolloClient, InMemoryCache } from '@apollo/client';
+import { IConfig } from '@/interfaces';
+
+/**
+ * Creates an Apollo Client instance configured for the appropriate environment
+ * @param config - The application config containing network and stage information
+ * @returns Configured Apollo Client instance
+ */
+export function createApolloClient(config: IConfig) {
+  // Determine the URI based on the environment
+  const uri = config.stage === 'production' 
+    ? 'https://api.troves.fi/' 
+    : 'http://localhost:4000';
+
+  return new ApolloClient({
+    uri,
+    cache: new InMemoryCache(),
+  });
+}
+
+// Default client for backward compatibility
+const apolloClient = new ApolloClient({
+  uri: 'https://api.troves.fi/',
+  cache: new InMemoryCache(),
+});
+
+export default apolloClient;
+

package/src/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,

package/src/modules/ekubo-pricer.ts

@@ -0,0 +1,79 @@
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
+import EkuboPricerAbi from '@/data/ekubo-price-fethcer.abi.json';
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
+
+export class EkuboPricer extends PricerBase {
+    EKUBO_PRICE_FETCHER_ADDRESS = '0x04946fb4ad5237d97bbb1256eba2080c4fe1de156da6a7f83e3b4823bb6d7da1';
+    readonly contract: Contract;
+    private readonly USDC_ADDRESS = '0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8';
+    private readonly USDC_DECIMALS = 6;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: EkuboPricerAbi, 
+            address: this.EKUBO_PRICE_FETCHER_ADDRESS, 
+            providerOrAccount: config.provider as RpcProvider
+        });
+    }
+
+    private div2Power128(num: bigint): number {
+        return Number((num * BigInt(1e18)) / BigInt(2 ** 128)) / 1e18;
+    }
+
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
+        if (!tokenAddr) {
+            throw new Error(`EkuboPricer:getPrice - no token`);
+        }
+
+        // get_prices arguments in order:
+        // - quote_token: USDC address (quote token for price calculation)
+        // - base_tokens: array containing the base token address/addresses
+        // - period: time period in seconds for TWAP (3600 = 1 hour)
+        // - min_token: minimum token amount threshold (min liquidity) in 6 Decimals = 1000000)
+        const result: any = await this.contract.call(
+            'get_prices',
+            [this.USDC_ADDRESS, [tokenAddr], 3600, 1000000],
+            { blockIdentifier }
+        );
+
+        if (!result || result.length === 0) {
+            throw new Error(`EkuboPricer: No price result returned for ${tokenAddr}`);
+        }
+
+        const priceResult = result[0];
+        
+        if (!priceResult?.variant?.Price) {
+            const variant = priceResult?.variant ? Object.keys(priceResult.variant)[0] : 'Unknown';
+            throw new Error(`EkuboPricer: Price fetch failed with variant: ${variant}`);
+        }
+
+        const rawPrice = typeof priceResult.variant.Price === 'string' 
+            ? BigInt(priceResult.variant.Price) 
+            : priceResult.variant.Price;
+
+        // Get token info to determine decimals from configured tokens
+        const tokenInfo = this.tokens.find(t => 
+            t.address.address.toLowerCase() === tokenAddr.toLowerCase()
+        );
+        
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenAddr} not found in global tokens`);
+        }
+
+        // Convert from x128 format
+        const priceAfterX128 = this.div2Power128(rawPrice);
+        
+        // Adjust for token decimals
+        const decimalAdjustment = 10 ** (tokenInfo.decimals - this.USDC_DECIMALS);
+        const price = priceAfterX128 * decimalAdjustment;
+
+        return {
+            price,
+            timestamp: new Date()
+        };
+    }
+}
+

package/src/modules/erc20.ts

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig } from "@/interfaces";
 import { Contract } from "starknet";
 import ERC20Abi from '@/data/erc20.abi.json';
-
+import { uint256 } from "starknet";
 export class ERC20 {
     readonly config: IConfig;
 
@@ -12,7 +12,7 @@ export class ERC20 {
 
     contract(addr: string | ContractAddr) {
         const _addr = typeof addr === 'string' ? addr : addr.address;
-        return new Contract({abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider});
+        return new Contract({ abi: ERC20Abi, address: _addr, providerOrAccount: this.config.provider });
     }
 
     async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {
@@ -26,4 +26,20 @@ export class ERC20 {
         const allowance = await contract.call('allowance', [owner.toString(), spender.toString()]);
         return Web3Number.fromWei(allowance.toString(), tokenDecimals);
     }
+
+    approve(
+        token: string | ContractAddr,
+        spender: string | ContractAddr,
+        amount: Web3Number
+    ) {
+        const contract = this.contract(token);
+        const amountUint256 = uint256.bnToUint256(amount.toWei());
+        const approveCall = contract.populate("approve", [
+            spender.toString(),
+            amountUint256.low.toString(),
+            amountUint256.high.toString(),
+        ]);
+        return approveCall;
+    }
+
 }

package/src/modules/pragma.ts

@@ -1,22 +1,37 @@
-import { Contract, RpcProvider } from "starknet";
+import { Contract, RpcProvider, BlockIdentifier } from "starknet";
 import PragmaAbi from '@/data/pragma.abi.json';
 import { logger } from "@/utils/logger";
+import { PricerBase } from "./pricerBase";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PriceInfo } from "./pricer";
 
-export class Pragma {
+export class Pragma extends PricerBase {
     contractAddr = '0x023fb3afbff2c0e3399f896dcf7400acf1a161941cfb386e34a123f228c62832';
     readonly contract: Contract;
 
-    constructor(provider: RpcProvider) {
-        this.contract = new Contract({abi: PragmaAbi, address: this.contractAddr, providerOrAccount: provider});
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+        this.contract = new Contract({
+            abi: PragmaAbi,
+            address: this.contractAddr,
+            providerOrAccount: config.provider as RpcProvider
+        });
     }
 
-    async getPrice(tokenAddr: string) {
+    async getPrice(tokenAddr: string, blockIdentifier: BlockIdentifier = 'latest'): Promise<PriceInfo> {
         if (!tokenAddr) {
             throw new Error(`Pragma:getPrice - no token`)
         }
-        const result: any = await this.contract.call('get_price', [tokenAddr]);
+        const result: any = await this.contract.call(
+            'get_price', 
+            [tokenAddr],
+            { blockIdentifier }
+        );
         const price = Number(result.price) / 10**8;
-        logger.verbose(`Pragma:${tokenAddr}: ${price}`);
-        return price;
+        logger.verbose(`Pragma:${tokenAddr}: ${price} at block ${blockIdentifier}`);
+        return {
+            price,
+            timestamp: new Date()
+        };
     }
 }