@strkfarm/sdk 1.0.28 → 1.0.30

package/src/dataTypes/_bignumber.ts

@@ -1,3 +1,4 @@
+import { logger } from "@/global";
 import BigNumber from "bignumber.js";
 
 export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
@@ -13,22 +14,22 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
     }
 
     multipliedBy(value: string | number | T): T {
-        let _value = Number(value).toFixed(this.maxToFixedDecimals());
+        const _value = this.getStandardString(value);
         return this.construct(this.mul(_value).toString(), this.decimals);
     }
 
     dividedBy(value: string | number | T): T {
-        let _value = Number(value).toFixed(this.maxToFixedDecimals());
+        const _value = this.getStandardString(value);
         return this.construct(this.div(_value).toString(), this.decimals);
     }
 
     plus(value: string | number | T): T {
-        const _value = Number(value).toFixed(this.maxToFixedDecimals());
+        const _value = this.getStandardString(value);
         return this.construct(this.add(_value).toString(), this.decimals);
     }
 
     minus(n: number | string | T, base?: number): T {
-        const _value = Number(n).toFixed(this.maxToFixedDecimals());
+        const _value = this.getStandardString(n);
         return this.construct(super.minus(_value, base).toString(), this.decimals);
     }
 
@@ -49,9 +50,16 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
     }
 
     private maxToFixedDecimals() {
-        return Math.min(this.decimals, 13);
+        return Math.min(this.decimals, 18);
+    }
+
+    private getStandardString(value: string | number | T): string {
+        if (typeof value == 'string') {
+            return value
+        }
+        return value.toFixed(this.maxToFixedDecimals())
     }
 }
 
-BigNumber.config({ DECIMAL_PLACES: 18 })
-_Web3Number.config({ DECIMAL_PLACES: 18 })
+BigNumber.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN })
+_Web3Number.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN })

package/src/global.ts

@@ -52,42 +52,48 @@ const defaultTokens: TokenInfo[] = [{
     logo: 'https://assets.coingecko.com/coins/images/26433/small/starknet.png',
     address: ContractAddr.from('0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d'),
     decimals: 18,
-    coingeckId: 'starknet'
+    coingeckId: 'starknet',
+    displayDecimals: 2,
 }, {
     name: 'xSTRK',
     symbol: 'xSTRK',
     logo: 'https://dashboard.endur.fi/endur-fi.svg',
     address: ContractAddr.from('0x028d709c875c0ceac3dce7065bec5328186dc89fe254527084d1689910954b0a'),
     decimals: 18,
-    coingeckId: undefined
+    coingeckId: undefined,
+    displayDecimals: 2,
 }, {
     name: 'ETH',
     symbol: 'ETH',
     logo: 'https://opbnb.bscscan.com/token/images/ether.svg',
     address: ContractAddr.from('0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7'),
     decimals: 18,
-    coingeckId: undefined
+    coingeckId: undefined,
+    displayDecimals: 4,
 }, {
     name: 'USDC',
     symbol: 'USDC',
     logo: 'https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png',
     address: ContractAddr.from('0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'),
     decimals: 6,
-    coingeckId: undefined
+    coingeckId: undefined,
+    displayDecimals: 2,
 }, {
     name: 'USDT',
     symbol: 'USDT',
     logo: 'https://assets.coingecko.com/coins/images/325/small/Tether.png',
     address: ContractAddr.from('0x68f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8'),
     decimals: 6,
-    coingeckId: undefined
+    coingeckId: undefined,
+    displayDecimals: 2,
 }, {
     name: 'WBTC',
     symbol: 'WBTC',
     logo: 'https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599/logo.png',
     address: ContractAddr.from('0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac'),
     decimals: 8,
-    coingeckId: undefined
+    coingeckId: undefined,
+    displayDecimals: 6,
 }]
 const tokens: TokenInfo[] = defaultTokens;
 
@@ -150,6 +156,7 @@ export class Global {
                 decimals: token.decimals,
                 logo: token.logoUri,
                 coingeckId: token.extensions.coingeckoId,
+                displayDecimals: 2
             });
         });
         console.log(tokens);

package/src/interfaces/common.ts

@@ -29,6 +29,7 @@ export interface TokenInfo {
     decimals: number,
     logo: string,
     coingeckId?: string,
+    displayDecimals: number
 }
 
 export enum Network {
@@ -73,10 +74,12 @@ export interface IStrategyMetadata<T> {
         netRisk: number,
         notARisks: string[]
     },
+    apyMethodology?: string,
     additionalInfo: T
 }
 
 export interface IInvestmentFlow {
+    id?: string, // used to link flows
     title: string,
     subItems: {key: string, value: string}[],
     linkedFlows: IInvestmentFlow[],

package/src/modules/avnu.ts

@@ -3,6 +3,7 @@ import { uint256 } from "starknet";
 import { Call, Uint256 } from "starknet";
 import { fetchBuildExecuteTransaction, fetchQuotes, Quote } from "@avnu/avnu-sdk";
 import { assert } from "../utils";
+import { logger } from "@/global";
 
 export interface Route {
     token_from: string,
@@ -26,68 +27,86 @@ export interface SwapInfo {
 
 
 export class AvnuWrapper {
-    async getQuotes(
-        fromToken: string,
-        toToken: string,
-        amountWei: string,
-        taker: string,
-    ) {
-        const params: any = {
-            sellTokenAddress: fromToken,
-            buyTokenAddress: toToken,
-            sellAmount: amountWei,
-            takerAddress: taker,
-        };
-        assert(fromToken != toToken, 'From and to tokens are the same');
+  async getQuotes(
+    fromToken: string,
+    toToken: string,
+    amountWei: string,
+    taker: string,
+    retry = 0
+  ): Promise<Quote> {
+    const MAX_RETRY = 5;
+    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    const params: any = {
+      sellTokenAddress: fromToken,
+      buyTokenAddress: toToken,
+      sellAmount: amountWei,
+      takerAddress: taker,
+    //   excludeSources: ['Nostra', 'Haiko(Solvers)']
+      excludeSources: ['Haiko(Solvers)'] // to resolve InvalidOraclePrice error
+    };
+    assert(fromToken != toToken, "From and to tokens are the same");
 
-        const quotes = await fetchQuotes(params);
-        assert(quotes.length > 0, 'No quotes found');
-        return quotes[0];
+    const quotes = await fetchQuotes(params);
+    if (quotes.length == 0) {
+        if (retry < MAX_RETRY) {
+            await new Promise((res) => setTimeout(res, 3000))
+            return await this.getQuotes(fromToken, toToken, amountWei, taker, retry + 1);
+        }
+        throw new Error('no quotes found')
     }
+    return quotes[0];
+  }
 
-    async getSwapInfo(
-        quote: Quote,
-        taker: string,
-        integratorFeeBps: number,
-        integratorFeeRecipient: string,
-        minAmount: string
-    ) {
-        const calldata = await  fetchBuildExecuteTransaction(quote.quoteId);
-        // its the multi swap function call
-        const call: Call = calldata.calls[1];
-        const callData: string[] = call.calldata as string[];
-        const routesLen: number = Number(callData[11]);
-        assert(routesLen > 0, 'No routes found');
-
-        // use call data to re-construct routes
-        let startIndex = 12;
-        const routes: Route[] = [];
-        for(let i=0; i<routesLen; ++i) {
-            const swap_params_len = Number(callData[startIndex + 4]);
-            const route: Route = {
-                token_from: callData[startIndex],
-                token_to: callData[startIndex + 1],
-                exchange_address: callData[startIndex + 2],
-                percent: Number(callData[startIndex + 3]),
-                additional_swap_params: swap_params_len > 0 ? callData.slice(startIndex + 5, startIndex + 5 + swap_params_len): []
-            }
-            routes.push(route);
-            startIndex += 5 + swap_params_len;
-        }
+  async getSwapInfo(
+    quote: Quote,
+    taker: string,
+    integratorFeeBps: number,
+    integratorFeeRecipient: string,
+    minAmount?: string
+  ) {
+    const calldata = await fetchBuildExecuteTransaction(quote.quoteId);
+    // its the multi swap function call
+    const call: Call = calldata.calls[1];
+    const callData: string[] = call.calldata as string[];
+    const routesLen: number = Number(callData[11]);
+    assert(routesLen > 0, "No routes found");
 
-        // swapInfo as expected by the strategy 
-        const swapInfo: SwapInfo = {
-            token_from_address: quote.sellTokenAddress, 
-            token_from_amount: uint256.bnToUint256(quote.sellAmount),
-            token_to_address: quote.buyTokenAddress,
-            token_to_amount: uint256.bnToUint256(quote.buyAmount), 
-            token_to_min_amount: uint256.bnToUint256(minAmount),
-            beneficiary: taker,
-            integrator_fee_amount_bps: integratorFeeBps,
-            integrator_fee_recipient: integratorFeeRecipient,
-            routes
-        };
-    
-        return swapInfo;
+    // use call data to re-construct routes
+    let startIndex = 12;
+    const routes: Route[] = [];
+    for (let i = 0; i < routesLen; ++i) {
+      const swap_params_len = Number(callData[startIndex + 4]);
+      const route: Route = {
+        token_from: callData[startIndex],
+        token_to: callData[startIndex + 1],
+        exchange_address: callData[startIndex + 2],
+        percent: Number(callData[startIndex + 3]),
+        additional_swap_params:
+          swap_params_len > 0
+            ? callData.slice(startIndex + 5, startIndex + 5 + swap_params_len)
+            : [],
+      };
+      routes.push(route);
+      startIndex += 5 + swap_params_len;
     }
+
+    // swapInfo as expected by the strategy
+    // fallback, max 1% slippage
+    const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    const swapInfo: SwapInfo = {
+      token_from_address: quote.sellTokenAddress,
+      token_from_amount: uint256.bnToUint256(quote.sellAmount),
+      token_to_address: quote.buyTokenAddress,
+      token_to_amount: uint256.bnToUint256(_minAmount),
+      token_to_min_amount: uint256.bnToUint256(_minAmount),
+      beneficiary: taker,
+      integrator_fee_amount_bps: integratorFeeBps,
+      integrator_fee_recipient: integratorFeeRecipient,
+      routes,
+    };
+
+    return swapInfo;
+  }
 }

package/src/modules/harvests.ts

@@ -0,0 +1,111 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { logger } from "@/global";
+import { IConfig } from "@/interfaces";
+import { assert } from "@/utils";
+import { Contract, num } from "starknet";
+
+export interface HarvestInfo {
+    rewardsContract: ContractAddr,
+    token: ContractAddr,
+    startDate: Date,
+    endDate: Date,
+    claim: {
+        id: number,
+        amount: Web3Number,
+        claimee: ContractAddr
+    },
+    actualReward: Web3Number,
+    proof: string[]
+}
+
+export class Harvests {   
+    constructor(protected readonly config: IConfig) {}
+
+    getHarvests(addr: ContractAddr): Promise<HarvestInfo[]> {
+        throw new Error("Not implemented");
+    }
+
+    async getUnHarvestedRewards(addr: ContractAddr) {
+        const rewards = await this.getHarvests(addr);
+        if (rewards.length == 0) return [];
+
+        const unClaimed: HarvestInfo[] = [];
+
+        const cls = await this.config.provider.getClassAt(rewards[0].rewardsContract.address);
+        for (let reward of rewards) {
+            const contract = new Contract(cls.abi, reward.rewardsContract.address, this.config.provider);
+            const isClaimed = await contract.call('is_claimed', [reward.claim.id]);
+            logger.verbose(`${Harvests.name}: isClaimed: ${isClaimed}`);
+            if (isClaimed)
+                return unClaimed;
+            unClaimed.unshift(reward); // to ensure older harvest is first
+        }
+        return unClaimed;
+    }
+}
+
+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}`
+        const resultEkubo = await fetch(EKUBO_API);
+        const items = (await resultEkubo.json());
+
+        const rewards: HarvestInfo[] = [];
+        for (let i=0; i<items.length; ++i) {
+            const info = items[i];
+            assert(info.token == STRK, 'expected strk token only')
+            rewards.push({
+                rewardsContract: ContractAddr.from(info.contract_address),
+                token: ContractAddr.from(STRK),
+                startDate: new Date(info.start_date),
+                endDate: new Date(info.end_date),
+                claim: {
+                    id: info.claim.id,
+                    amount: Web3Number.fromWei(info.claim.amount, 18),
+                    claimee: ContractAddr.from(info.claim.claimee)
+                },
+                actualReward: Web3Number.fromWei(info.claim.amount, 18),
+                proof: info.proof
+            });
+        }
+        return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
+    }
+}
+
+export class VesuHarvests extends Harvests {
+    async getHarvests(addr: ContractAddr): Promise<HarvestInfo[]> {
+        const result = await fetch(`https://api.vesu.xyz/users/${addr.address}/strk-rewards/calldata`);
+        const data = await result.json();
+        const rewardsContract = ContractAddr.from('0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F');
+    
+        // get already claimed amount
+        const cls = await this.config.provider.getClassAt(rewardsContract.address);
+        const contract = new Contract(cls.abi, rewardsContract.address, this.config.provider);
+        const _claimed_amount: any = await contract.call('amount_already_claimed', [addr.address]);
+        const claimed_amount = Web3Number.fromWei(_claimed_amount.toString(), 18);
+        logger.verbose(`${VesuHarvests.name}: claimed_amount: ${claimed_amount.toString()}`);
+        
+        // get the actual reward
+        const actualReward = Web3Number.fromWei(data.data.amount, 18).minus(claimed_amount);
+        logger.verbose(`${VesuHarvests.name}: actualReward: ${actualReward.toString()}`);
+        return [{
+            rewardsContract,
+            token: ContractAddr.from(STRK),
+            startDate: new Date(0),
+            endDate: new Date(0),
+            claim: {
+                id: 0,
+                amount: Web3Number.fromWei(num.getDecimalString(data.data.amount), 18),
+                claimee: addr
+            },
+            actualReward,
+            proof: data.data.proof
+        }]
+    }
+
+    async getUnHarvestedRewards(addr: ContractAddr) {
+        return await this.getHarvests(addr);
+    }
+}

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

@@ -12,8 +12,8 @@ export class PricerFromApi extends PricerBase {
     async getPrice(tokenSymbol: string): Promise<PriceInfo> {
         try {
             return await this.getPriceFromMyAPI(tokenSymbol);
-        } catch (e) {
-            logger.warn('getPriceFromMyAPI error', e);
+        } catch (e: any) {
+            logger.warn('getPriceFromMyAPI error', JSON.stringify(e.message || e));
         }
         logger.log('getPrice coinbase', tokenSymbol);
         let retry = 0;
@@ -32,8 +32,8 @@ export class PricerFromApi extends PricerBase {
                     price,
                     timestamp: new Date()
                 }
-            } catch (e) {
-                logger.warn('getPrice coinbase error', e, retry);
+            } catch (e: any) {
+                logger.warn('getPrice coinbase error', JSON.stringify(e.message || e));
                 await new Promise((resolve) => setTimeout(resolve, retry * 1000));
             }
         }
@@ -48,10 +48,11 @@ export class PricerFromApi extends PricerBase {
         const priceInfo = await priceInfoRes.json();
         const now = new Date();
         const priceTime = new Date(priceInfo.timestamp);
-        if (now.getTime() - priceTime.getTime() > 900000) {
-          // 15 mins
-          throw new Error('Price is stale');
-        }
+        // 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,

package/src/modules/zkLend.ts

@@ -40,7 +40,8 @@ export class ZkLend extends ILending implements ILending {
                     logo: '',
                     decimals: pool.token.decimals,
                     borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),
-                    collareralFactor
+                    collareralFactor,
+                    displayDecimals: 2
                 }
                 this.tokens.push(token);
             });

package/src/strategies/base-strategy.ts

@@ -16,7 +16,7 @@ export interface DualActionAmount {
     token1: SingleActionAmount
 }
 export interface DualTokenInfo {
-    netUsdValue: number,
+    usdValue: number,
     token0: SingleTokenInfo,
     token1: SingleTokenInfo
 }
@@ -36,11 +36,11 @@ export class BaseStrategy<TVLInfo, ActionInfo> {
         throw new Error("Not implemented");
     }   
 
-    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Call[] {
+    async depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }
 
-    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Call[] {
+    async withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
         throw new Error("Not implemented");
     }