@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.51

package/src/modules/harvests.ts

@@ -29,28 +29,36 @@ export class Harvests {
 
     async getUnHarvestedRewards(addr: ContractAddr) {
         const rewards = await this.getHarvests(addr);
+        logger.verbose(`${Harvests.name}: getUnHarvestedRewards => rewards length: ${rewards.length}`);
         if (rewards.length == 0) return [];
 
         const unClaimed: HarvestInfo[] = [];
 
         // use the latest one
-        const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
-
-        const cls = await this.config.provider.getClassAt(reward.rewardsContract.address);
-        const contract = new Contract({abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider});
-        const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
-        logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}`);
-        if (isClaimed) {
-            return unClaimed;
-        }
-        // rewards contract must have enough balance to claim
-        const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
-        if (bal.lessThan(reward.claim.amount)) {
-            logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
-            return unClaimed;
+        const sortedRewards = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
+        if (sortedRewards.length == 0) {
+            logger.verbose(`${Harvests.name}: no rewards found`);
+            return [];
         }
 
-        unClaimed.unshift(reward); // to ensure older harvest is first
+        const cls = await this.config.provider.getClassAt(sortedRewards[0].rewardsContract.address);
+
+        for (const reward of sortedRewards) {
+            const contract = new Contract({abi: cls.abi, address: reward.rewardsContract.address, providerOrAccount: this.config.provider});
+            const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
+            logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}, claim id: ${reward.claim.id}, address: ${reward.rewardsContract.address}`);
+            if (isClaimed) {
+                continue;
+            }
+            // rewards contract must have enough balance to claim
+            const bal = await (new ERC20(this.config)).balanceOf(reward.token, reward.rewardsContract.address, 18);
+            if (bal.lessThan(reward.claim.amount)) {
+                logger.verbose(`${Harvests.name}: balance: ${bal.toString()}, amount: ${reward.claim.amount.toString()}`);
+                continue;
+            }
+
+            unClaimed.push(reward); // to ensure older harvest is first
+        }
         return unClaimed;
     }
 }
@@ -59,26 +67,28 @@ const STRK = '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d'
 
 export class EkuboHarvests extends Harvests {
     async getHarvests(addr: ContractAddr) {
-        const EKUBO_API = `https://starknet-mainnet-api.ekubo.org/airdrops/${addr.address}?token=${STRK}`
+        logger.verbose(`${EkuboHarvests.name}: getHarvests => addr: ${addr.address}`);
+        const EKUBO_API = `https://prod-api.ekubo.org/claims/${addr.address}`
         const resultEkubo = await fetch(EKUBO_API);
-        const items = (await resultEkubo.json());
-
+        const data = (await resultEkubo.json());
+        const claims = data.claims || [];
+        logger.verbose(`${EkuboHarvests.name}: getHarvests => claims length: ${claims.length}`);
         const rewards: HarvestInfo[] = [];
-        for (let i=0; i<items.length; ++i) {
-            const info = items[i];
-            assert(info.token == STRK, 'expected strk token only')
+        for (let i=0; i<claims.length; ++i) {
+            const claimData = claims[i];
+            assert(claimData.key.token == STRK, 'expected strk token only')
             rewards.push({
-                rewardsContract: ContractAddr.from(info.contract_address),
+                rewardsContract: ContractAddr.from(claimData.dropAddress),
                 token: ContractAddr.from(STRK),
-                startDate: new Date(info.start_date),
-                endDate: new Date(info.end_date),
+                startDate: new Date(0),
+                endDate: new Date(0),
                 claim: {
-                    id: info.claim.id,
-                    amount: Web3Number.fromWei(info.claim.amount, 18),
-                    claimee: ContractAddr.from(info.claim.claimee)
+                    id: claimData.claim.index,
+                    amount: Web3Number.fromWei(claimData.claim.amount, 18),
+                    claimee: ContractAddr.from(claimData.claim.account)
                 },
-                actualReward: Web3Number.fromWei(info.claim.amount, 18),
-                proof: info.proof
+                actualReward: Web3Number.fromWei(claimData.claim.amount, 18),
+                proof: claimData.proof
             });
         }
         return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
@@ -101,6 +111,10 @@ export class VesuHarvests extends Harvests {
         logger.verbose(`${VesuHarvests.name}: claimed_amount: ${claimed_amount.toString()}`);
         
         const data = _data.data['defiSpring'];
+        if (!data) {
+            logger.verbose(`${VesuHarvests.name}: no defiSpring data found`);
+            return [];
+        }
 
         // get the actual reward
         const actualReward = Web3Number.fromWei(data.amount, 18).minus(claimed_amount);

package/src/modules/index.ts

@@ -1,5 +1,6 @@
 export * from './token-market-data';
 export * from './pricer';
+export * from './pricer-avnu-api';
 export * from './pragma';
 export * from './zkLend';
 export * from './pricer-from-api';
@@ -10,4 +11,4 @@ export * from './pricer-lst';
 export * from './lst-apr';
 export * from './pricerBase';
 export * from './midas';
-export * from './ExtendedWrapperSDk';
+export * from './ekubo-pricer';

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()
+        };
     }
 }

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

@@ -0,0 +1,114 @@
+import axios from "axios";
+import { TokenInfo } from "@/interfaces/common";
+import { IConfig } from "@/interfaces/common";
+import { PricerBase } from "./pricerBase";
+import { PriceInfo } from "./pricer";
+import { logger } from "@/utils/logger";
+import { ContractAddr } from "@/dataTypes";
+
+const AVNU_TOKENS_API = "https://starknet.impulse.avnu.fi/v3/tokens";
+
+interface AvnuTokenApiEntry {
+    address: string;
+    symbol: string;
+    starknet?: {
+        usd?: number;
+    };
+}
+
+/**
+ * Polls Avnu impulse tokens API and keeps USD prices in memory for configured tokens.
+ * Price timestamp is set when each poll request completes.
+ */
+export class PricerAvnuApi extends PricerBase {
+    protected prices: { [key: string]: PriceInfo } = {};
+
+    readonly refreshInterval = 15_000;
+    readonly staleTime = 5 * 60 * 1000;
+
+    private pollTimer: ReturnType<typeof setInterval> | null = null;
+    private loading = false;
+
+    constructor(config: IConfig, tokens: TokenInfo[]) {
+        super(config, tokens);
+    }
+
+    start() {
+        this._loadPrices();
+        this.pollTimer = setInterval(() => {
+            this._loadPrices();
+        }, this.refreshInterval);
+    }
+
+    stop() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+
+    isStale(timestamp: Date) {
+        return Date.now() - timestamp.getTime() > this.staleTime;
+    }
+
+    hasPrice(tokenSymbol: string) {
+        const info = this.prices[tokenSymbol];
+        return !!info && !this.isStale(info.timestamp);
+    }
+
+    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+        const info = this.prices[tokenSymbol];
+        if (!info) {
+            throw new Error(`AvnuApi: price of ${tokenSymbol} not found`);
+        }
+        if (this.isStale(info.timestamp)) {
+            throw new Error(`AvnuApi: price of ${tokenSymbol} is stale`);
+        }
+        return info;
+    }
+
+    protected async _loadPrices() {
+        if (this.loading) {
+            return;
+        }
+        this.loading = true;
+        const timestamp = new Date();
+        try {
+            const result = await axios.get<AvnuTokenApiEntry[]>(AVNU_TOKENS_API);
+            const priceByAddress = new Map<string, number>();
+            for (const entry of result.data) {
+                const usd = entry.starknet?.usd;
+                if (usd != null && usd > 0) {
+                    priceByAddress.set(ContractAddr.standardise(entry.address), usd);
+                }
+            }
+
+            for (const token of this.tokens) {
+                if (token.symbol === "USDT" || token.symbol === "USDC") {
+                    this.prices[token.symbol] = { price: 1, timestamp };
+                    continue;
+                }
+
+                const targetToken = token.priceProxySymbol
+                    ? this.tokens.find((t) => t.symbol === token.priceProxySymbol)
+                    : token;
+                if (!targetToken) {
+                    continue;
+                }
+
+                const addr = targetToken.address.address;
+                const price = priceByAddress.get(addr);
+                if (price != null) {
+                    this.prices[token.symbol] = { price, timestamp };
+                    logger.verbose(
+                        `AvnuApi: ${token.symbol} -> $${price}`,
+                    );
+                }
+            }
+        } catch (error: any) {
+            logger.warn(`AvnuApi: failed to fetch tokens: ${error?.message ?? error}`);
+        } finally {
+            this.loading = false;
+        }
+    }
+}

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

@@ -1,21 +1,67 @@
-    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 (symbol) => {
+            const priceInfo = await this.getPriceFromMyAPI(symbol);
+            return priceInfo.price;
+        });
     }
 
-    async getPrice(tokenSymbol: string): Promise<PriceInfo> {
+    async getPrice(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`);
+        }
+        const symbol = tokenInfo.priceProxySymbol || tokenInfo.symbol;
+        // If blockNumber is provided, fetch historical price from GraphQL
+        if (blockNumber !== undefined) {
+            try {
+                return await this.getHistoricalPrice(symbol, 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);
+            return await this.getPriceFromMyAPI(symbol);
         } catch (e: any) {
-            logger.warn('getPriceFromMyAPI error', e);
+            logger.warn(`API price fetch failed for ${tokenSymbol}: ${e.message}, trying coinbase`);
         }
-        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 +87,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-lst.ts

@@ -6,7 +6,7 @@ import axios from "axios";
 
 export class PricerLST extends Pricer {
   private tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[];
-  protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
+  protected EKUBO_API = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_ADDRESS}}/{{UNDERLYING_ADDRESS}}'; // e.g. xSTRK/STRK
 
   constructor(config: IConfig, tokenMaps: {lst: TokenInfo, underlying: TokenInfo}[]) {
     const refreshInterval = 5000;

package/src/modules/pricer-quote-utils.ts

@@ -0,0 +1,54 @@
+import { TokenInfo } from "@/interfaces/common";
+
+export const PRICER_USDC_ADDRESS =
+    "0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb";
+export const PRICER_USDC_DECIMALS = 6;
+
+export interface QuoteTokenConfig {
+    address: string;
+    decimals: number;
+    symbol: string;
+    isUsdQuote: boolean;
+}
+
+export function resolveQuoteTokenConfig(token: TokenInfo, tokens: TokenInfo[]): QuoteTokenConfig {
+    if (token.intermediateQuoteTokenSymbol) {
+        const intermediateToken = tokens.find(
+            (t) => t.symbol === token.intermediateQuoteTokenSymbol,
+        );
+        if (!intermediateToken) {
+            throw new Error(
+                `Intermediate quote token ${token.intermediateQuoteTokenSymbol} not found for ${token.symbol}`,
+            );
+        }
+
+        return {
+            address: intermediateToken.address.toString(),
+            decimals: intermediateToken.decimals,
+            symbol: intermediateToken.symbol,
+            isUsdQuote: false,
+        };
+    }
+
+    return {
+        address: PRICER_USDC_ADDRESS,
+        decimals: PRICER_USDC_DECIMALS,
+        symbol: "USDC",
+        isUsdQuote: true,
+    };
+}
+
+export async function convertQuoteAmountToUsd(
+    tokenSymbol: string,
+    quoteAmount: number,
+    quoteConfig: QuoteTokenConfig,
+    resolveUsdPrice: (symbol: string) => Promise<number>,
+): Promise<number> {
+    if (quoteConfig.isUsdQuote) {
+        const usdcPrice = await resolveUsdPrice("USDC");
+        return quoteAmount * usdcPrice;
+    }
+
+    const intermediateUsdPrice = await resolveUsdPrice(quoteConfig.symbol);
+    return quoteAmount * intermediateUsdPrice;
+}