@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

package/src/modules/pricer-from-api.ts

@@ -1,21 +1,59 @@
-    import { PriceInfo } from "./pricer";
+import { PriceInfo } from "./pricer";
 import axios from "axios";
 import { IConfig, TokenInfo } from "@/interfaces";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
+import { createApolloClient } from "./apollo-client-config";
+import { gql } from "@apollo/client";
+import { ContractAddr } from "@/dataTypes";
+import { Pragma } from "./pragma";
+import { EkuboPricer } from "./ekubo-pricer";
+import { BlockIdentifier } from "starknet";
 
 export class PricerFromApi extends PricerBase {
+    private apolloClient: ReturnType<typeof createApolloClient>;
+    private pragma: Pragma;
+    private ekuboPricer: EkuboPricer;
+    
+    // Tokens supported by Pragma and GraphQL for historical prices (standardized addresses)
+    // Note: xSTRK is not supported by Pragma RPC, so it will use Ekubo pricer instead
+    private readonly PRAGMA_SUPPORTED_TOKENS = [
+        ContractAddr.from('0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac').address, // WBTC
+        ContractAddr.from('0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8').address, // USDC
+        ContractAddr.from('0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d').address, // STRK
+        // xSTRK removed - not supported by Pragma RPC, will use Ekubo pricer
+        // ContractAddr.from('0x28d709c875c0ceac3dce7065bec5328186dc89fe254527084d1689910954b0a').address, // xSTRK
+        ContractAddr.from('0x68f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8').address, // USDT
+        ContractAddr.from('0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7').address, // ETH
+    ];
+
     constructor(config: IConfig, tokens: TokenInfo[]) {
         super(config, tokens);
+        this.apolloClient = createApolloClient(config);
+        this.pragma = new Pragma(config, tokens);
+        this.ekuboPricer = new EkuboPricer(config, tokens);
     }
 
-    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo> {
+        // If blockNumber is provided, fetch historical price from GraphQL
+        if (blockNumber !== undefined) {
+            try {
+                return await this.getHistoricalPrice(tokenSymbol, blockNumber);
+            } catch (e: any) {
+                logger.error(`Historical price fetch failed for ${tokenSymbol}: ${e.message}`);
+                throw new Error('Server Error in fetching historical price')
+                // Fall back to current price if historical price is not available
+            }
+        }
+
+        // Otherwise, fetch current price
         try {
             return await this.getPriceFromMyAPI(tokenSymbol);
         } catch (e: any) {
-            logger.warn('getPriceFromMyAPI error', e);
+            logger.error(`API price fetch failed for ${tokenSymbol}: ${e.message}`);
         }
-        logger.info('getPrice coinbase', tokenSymbol);
+        
+        logger.info(`Using Coinbase price for ${tokenSymbol}`);
         let retry = 0;
         const MAX_RETRIES = 5;
         for (retry = 1; retry < MAX_RETRIES + 1; retry++) {
@@ -41,22 +79,120 @@ export class PricerFromApi extends PricerBase {
     }
 
     async getPriceFromMyAPI(tokenSymbol: string) {
-        logger.verbose(`getPrice from api: ${tokenSymbol}`);
         const endpoint = 'https://proxy.api.troves.fi'
         const url = `${endpoint}/api/price/${tokenSymbol}`;
         const priceInfoRes = await fetch(url);
         const priceInfo = await priceInfoRes.json();
-        const now = new Date();
-        const priceTime = new Date(priceInfo.timestamp);
-        // if (now.getTime() - priceTime.getTime() > 900000) {
-        //   // 15 mins
-        //   logger.verbose(`Price is stale: ${tokenSymbol}, timestamp: ${priceInfo.timestamp}, price: ${priceInfo.price}`);
-        //   throw new Error('Price is stale');
-        // }
         const price = Number(priceInfo.price);
         return {
             price,
             timestamp: new Date(priceInfo.timestamp)
         }
-      }
-}
+    }
+
+    /**
+     * Fetches historical price for a token at a specific block number
+     * @param tokenSymbol - The token symbol to get price for
+     * @param blockNumber - The block number to query
+     * @returns PriceInfo with price at the closest block <= blockNumber
+     */
+    async getHistoricalPrice(tokenSymbol: string, blockNumber: BlockIdentifier): Promise<PriceInfo> {
+        const tokenInfo = this.tokens.find(t => t.symbol === tokenSymbol);
+        if (!tokenInfo) {
+            throw new Error(`Token ${tokenSymbol} not found in configured tokens`);
+        }
+
+        // If blockNumber is not a number, fall back to current price
+        if (typeof blockNumber !== 'number') {
+            logger.info(`Non-numeric blockIdentifier '${blockNumber}' provided, fetching current price for ${tokenSymbol}`);
+            return await this.getPriceFromMyAPI(tokenSymbol);
+        }
+
+        const standardizedAddress = ContractAddr.from(tokenInfo.address.address).address;
+        const isPragmaSupported = this.PRAGMA_SUPPORTED_TOKENS.includes(standardizedAddress);
+
+        // Step 1: Try GraphQL first for ALL tokens
+        let data;
+        try {
+            const result = await this.apolloClient.query({
+                query: gql`
+                    query GetHistoricalPrice($asset: String!, $blockNumber: Int!) {
+                        findFirstPrices(
+                            where: { 
+                                asset: { equals: $asset }, 
+                                block_number: { lte: $blockNumber } 
+                            }
+                            orderBy: { block_number: desc }
+                        ) {
+                            price
+                            timestamp
+                            block_number
+                        }
+                    }
+                `,
+                variables: {
+                    asset: standardizedAddress,
+                    blockNumber: blockNumber,
+                },
+            });
+            data = result.data;
+        } catch (graphqlError: any) {
+            logger.error(`GraphQL query failed for ${tokenSymbol}: ${graphqlError.message}`);
+        }
+
+        // Step 2: If GraphQL has data, check block difference and use it if acceptable
+        if (data?.findFirstPrices) {
+            const priceData = data.findFirstPrices;
+            const blockDifference = blockNumber - priceData.block_number;
+            const MAX_BLOCK_DIFFERENCE = 6800; // ~6 hours worth of blocks
+            
+            if (blockDifference <= MAX_BLOCK_DIFFERENCE) {
+                logger.info(`Using GraphQL price for ${tokenSymbol} at block ${priceData.block_number}`);
+                return {
+                    price: Number(priceData.price),
+                    timestamp: new Date(priceData.timestamp * 1000), 
+                };
+            }
+            
+            logger.info(
+                `Block difference ${blockDifference} exceeds limit for ${tokenSymbol}. ` +
+                `Will try fallback sources at block ${blockNumber}`
+            );
+        } else {
+            logger.info(`No GraphQL data for ${tokenSymbol} at block ${blockNumber}, trying fallback sources`);
+        }
+
+        // Step 3: Fallback to Pragma (for supported tokens) or Ekubo (for non-supported tokens)
+        if (isPragmaSupported) {
+            logger.info(`Attempting Pragma RPC fetch for ${tokenSymbol} at block ${blockNumber}`);
+            try {
+                const priceInfo = await this.pragma.getPrice(tokenInfo.address.address, blockNumber);
+                logger.info(`Using Pragma price for ${tokenSymbol}: ${priceInfo.price}`);
+                return {
+                    price: priceInfo.price,
+                    timestamp: priceInfo.timestamp,
+                };
+            } catch (error: any) {
+                logger.error(`Pragma RPC failed for ${tokenSymbol} at block ${blockNumber}: ${error.message}`);
+                throw new Error(`Server Error at Pragma token ${tokenSymbol} at block ${blockNumber}`);
+            }
+        } else {
+            // For non-Pragma tokens, use Ekubo pricer
+            logger.info(`Attempting Ekubo price fetch for ${tokenSymbol} at block ${blockNumber}`);
+            try {
+                const priceInfo = await this.ekuboPricer.getPrice(
+                    tokenInfo.address.address,
+                    blockNumber
+                );
+                logger.info(`Using Ekubo price for ${tokenSymbol}: ${priceInfo.price}`);
+                return {
+                    price: priceInfo.price,
+                    timestamp: priceInfo.timestamp,
+                };
+            } catch (error: any) {
+                logger.error(`Ekubo RPC failed for ${tokenSymbol} at block ${blockNumber}: ${error.message}`);
+                throw new Error(`Server Error at Ekubo token ${tokenSymbol} at block ${blockNumber}`);
+            }
+        }
+    }
+}

package/src/modules/pricer.ts

@@ -5,6 +5,7 @@ import { IConfig } from "@/interfaces/common";
 import { Web3Number } from "@/dataTypes";
 import { PricerBase } from "./pricerBase";
 import { logger } from "@/utils/logger";
+import { BlockIdentifier } from "starknet";
 
 export interface PriceInfo {
     price: number,
@@ -81,7 +82,7 @@ export class Pricer extends PricerBase {
         Global.assert(!this.isStale(timestamp, tokenName), `Price of ${tokenName} is stale`);
 
     }
-    async getPrice(tokenSymbol: string) {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier) {
         Global.assert(this.prices[tokenSymbol], `Price of ${tokenSymbol} not found`);
        this.assertNotStale(this.prices[tokenSymbol].timestamp, tokenSymbol);
         return this.prices[tokenSymbol];

package/src/modules/pricerBase.ts

@@ -1,5 +1,6 @@
 import { IConfig, TokenInfo } from "@/interfaces";
 import { PriceInfo } from "./pricer";
+import { BlockIdentifier } from "starknet";
 
 export abstract class PricerBase {
     readonly config: IConfig;
@@ -9,7 +10,7 @@ export abstract class PricerBase {
         this.tokens = tokens;
     }
 
-    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier): Promise<PriceInfo> {
         throw new Error('Method not implemented');
     }
 }

package/src/node/deployer.ts

@@ -4,6 +4,7 @@ import { readFileSync, existsSync, writeFileSync } from 'fs'
 import { IConfig } from '../interfaces';
 import { Store, getDefaultStoreConfig } from '../utils/store';
 import { add } from 'winston';
+import { logger } from '@/utils';
 
 function getContracts() {
     const PATH = './contracts.json'
@@ -207,13 +208,47 @@ async function executeTransactions(
     return tx;
 }
 
+async function myWaitForTransaction(
+    transaction_hash: string,
+    provider: RpcProvider,
+    retry = 0
+) {
+    const MAX_RETRIES = 60;
+    logger.verbose(`Waiting for transaction: ${transaction_hash}, retry: ${retry}`);
+    try {
+        const status = await provider.getTransactionStatus(transaction_hash);
+        logger.verbose(`Transaction status: ${JSON.stringify(status.execution_status)}`);
+        if (status.execution_status == TransactionExecutionStatus.SUCCEEDED) {
+            return true;
+        }
+        if (status.execution_status == TransactionExecutionStatus.REVERTED) {
+            throw new Error(`Transaction reverted: ${transaction_hash}`);
+        }
+        if (retry > MAX_RETRIES) {
+            throw new Error(`Transaction not found: ${transaction_hash}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return myWaitForTransaction(transaction_hash, provider, retry + 1);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes('Transaction reverted')) {
+            throw new Error(`Transaction reverted: ${transaction_hash}`);
+        }
+        if (retry > MAX_RETRIES) {
+            throw error;
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return myWaitForTransaction(transaction_hash, provider, retry + 1);
+    }
+}
+
 const Deployer = {
     getAccount,
     myDeclare,
     deployContract,
     prepareMultiDeployContracts,
     executeDeployCalls,
-    executeTransactions
+    executeTransactions,
+    myWaitForTransaction
 }
 
 export default Deployer;

package/src/node/pricer-redis.ts

@@ -4,6 +4,7 @@ import { PriceInfo, Pricer } from '@/modules/pricer';
 import { createClient } from 'redis';
 import type { RedisClientType } from 'redis'
 import { logger } from "@/utils/logger";
+import { BlockIdentifier } from "starknet";
 
 export class PricerRedis extends Pricer {
     private redisClient: RedisClientType | null = null;
@@ -51,7 +52,7 @@ export class PricerRedis extends Pricer {
     }
 
     /** Returns price from redis */
-    async getPrice(tokenSymbol: string) {
+    async getPrice(tokenSymbol: string, blockNumber?: BlockIdentifier) {
         const STALE_TIME = 60000;
         if (!this.redisClient) {
             throw new FatalError(`Redis client not initialised`);

package/src/strategies/autoCompounderStrk.ts

@@ -48,7 +48,7 @@ export class AutoCompounderSTRK {
 
     /** Returns shares of user */
     async balanceOf(user: ContractAddr) {
-        const result = await this.contract!.balance_of(user.address);
+        const result = await this.contract!.balanceOf(user.address);
         return Web3Number.fromWei(result.toString(), this.metadata.decimals);
     }
 

package/src/strategies/base-strategy.ts

@@ -1,8 +1,8 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo, VaultPosition } from "@/interfaces";
+import { HarvestInfo } from "@/modules/harvests";
 import { CacheClass } from "@/utils/cacheClass";
-import { Call } from "starknet";
-import { PositionInfo } from "./universal-adapters";
+import { Call, BlockIdentifier } from "starknet";
 
 export interface SingleActionAmount {
     tokenInfo: TokenInfo,
@@ -13,11 +13,6 @@ export interface SingleTokenInfo extends SingleActionAmount {
     usdValue: number
 };
 
-export interface APYInfo {
-    net: number;
-    splits: { apy: number; id: string; }[];
-};
-
 export interface DualActionAmount {
     token0: SingleActionAmount,
     token1: SingleActionAmount
@@ -42,7 +37,7 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         this.config = config;
     }
 
-    async getUserTVL(user: ContractAddr): Promise<TVLInfo> {
+    async getUserTVL(user: ContractAddr, blockIdentifier?: BlockIdentifier): Promise<TVLInfo> {
         throw new Error("Not implemented");
     }
 
@@ -62,19 +57,7 @@ export class BaseStrategy<TVLInfo, ActionInfo> extends CacheClass {
         throw new Error("Not implemented");
     }
 
-    async getUnusedBalance(): Promise<SingleTokenInfo> {
-        throw new Error("Not implemented");
-    }
-
-    async netAPY(): Promise<APYInfo> {
-        throw new Error("Not implemented");
-    }
-
-    async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: PositionInfo[]}> {
-        throw new Error("Not implemented");
-    }
-
-    async getHealthFactors(): Promise<number[]> {
-        throw new Error("Not implemented");
+    async getPendingRewards(): Promise<HarvestInfo[]> {
+        return [];
     }
 }