@strkfarm/sdk 1.1.39 → 1.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.39",
+  "version": "1.1.41",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/global.ts

@@ -136,6 +136,24 @@ const defaultTokens: TokenInfo[] = [{
     displayDecimals: 6,
     priceProxySymbol: 'WBTC',
     priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
+}, {
+    name: 'mRe7BTC',
+    symbol: 'mRe7BTC',
+    logo: 'https://imagedelivery.net/0xPAQaDtnQhBs8IzYRIlNg/3a62ecee-1e58-45d3-9862-3ce90dff1900/logo',
+    address: ContractAddr.from('0x4e4fb1a9ca7e84bae609b9dc0078ad7719e49187ae7e425bb47d131710eddac'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.0001, // 112000 * 0.0001 = $11.2
+}, {
+    name: 'mRe7YIELD',
+    symbol: 'mRe7YIELD',
+    logo: 'https://midas.app/assets/mre7-BcOOHm7i.svg',
+    address: ContractAddr.from('0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 2,
+    priceCheckAmount: 100,
 }]
 const tokens: TokenInfo[] = defaultTokens;
 

package/src/modules/avnu.ts

@@ -120,17 +120,18 @@ export class AvnuWrapper {
 
   static buildZeroSwap(
     tokenToSell: ContractAddr,
-    address: string
+    beneficiary: string,
+    tokenToBuy: ContractAddr = tokenToSell
   ): SwapInfo {
     return {
       token_from_address: tokenToSell.address,
       token_from_amount: uint256.bnToUint256(0),
-      token_to_address: tokenToSell.address,
+      token_to_address: tokenToBuy.address,
       token_to_amount: uint256.bnToUint256(0),
       token_to_min_amount: uint256.bnToUint256(0),
-      beneficiary: address,
+      beneficiary: beneficiary,
       integrator_fee_amount_bps: 0,
-      integrator_fee_recipient: address,
+      integrator_fee_recipient: beneficiary,
       routes: [],
     };
   }

package/src/modules/harvests.ts

@@ -33,23 +33,24 @@ export class Harvests {
 
         const unClaimed: HarvestInfo[] = [];
 
-        const cls = await this.config.provider.getClassAt(rewards[0].rewardsContract.address);
-        for (let reward of rewards) {
-            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()}`);
-                continue;
-            }
+        // use the latest one
+        const reward = rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime())[0];
 
-            unClaimed.unshift(reward); // to ensure older harvest is first
+        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;
+        }
+
+        unClaimed.unshift(reward); // to ensure older harvest is first
         return unClaimed;
     }
 }

package/src/strategies/ekubo-cl-vault.tsx

@@ -33,12 +33,13 @@ import { BaseStrategy } from "./base-strategy";
 import { DualActionAmount } from "./base-strategy";
 import { DualTokenInfo } from "./base-strategy";
 import { log } from "winston";
-import { EkuboHarvests } from "@/modules/harvests";
+import { EkuboHarvests, HarvestInfo } from "@/modules/harvests";
 import { logger } from "@/utils/logger";
 import { COMMON_CONTRACTS } from "./constants";
 import { DepegRiskLevel, ImpermanentLossLevel, MarketRiskLevel, SmartContractRiskLevel } from "@/interfaces/risks";
 import { gql } from "@apollo/client";
 import apolloClient from "@/modules/apollo-client";
+import { binarySearch } from "@/utils/math-utils";
 
 export interface EkuboPoolKey {
   token0: ContractAddr;
@@ -481,7 +482,6 @@ export class EkuboCLVault extends BaseStrategy<
     for (let i = len - 1; i >= 0; --i) {
       let record: any = await this.contract.call("get_rewards_info", [i]);
       logger.verbose(`${EkuboCLVault.name}: getHarvestRewardShares: ${i}`);
-      console.log(record);
       const block = Number(record.block_number);
       if (block < fromBlock) {
         return shares;
@@ -713,16 +713,10 @@ export class EkuboCLVault extends BaseStrategy<
     const sqrtRatio = EkuboCLVault.div2Power128(
       BigInt(priceInfo.sqrt_ratio.toString())
     );
-    console.log(
-      `EkuboCLVault: getCurrentPrice: blockIdentifier: ${blockIdentifier}, sqrtRatio: ${sqrtRatio}, ${priceInfo.sqrt_ratio.toString()}`
-    );
     const token0Info = await Global.getTokenInfoFromAddr(poolKey.token0);
     const token1Info = await Global.getTokenInfoFromAddr(poolKey.token1);
     const price = sqrtRatio * sqrtRatio * (10 ** token0Info.decimals) / ( 10 ** token1Info.decimals);
     const tick = priceInfo.tick;
-    console.log(
-      `EkuboCLVault: getCurrentPrice: blockIdentifier: ${blockIdentifier}, price: ${price}, tick: ${tick.mag}, ${tick.sign}`
-    );
     return {
       price,
       tick: Number(tick.mag) * (tick.sign ? -1 : 1),
@@ -1592,70 +1586,249 @@ export class EkuboCLVault extends BaseStrategy<
         }: harvest => Processing claim, isToken1: ${isToken1} amount: ${postFeeAmount.toWei()}`
       );
 
-      // todo what if the claim token is neither token0 or token1
-      const token0Amt = isToken1
-        ? new Web3Number(0, token0Info.decimals)
-        : postFeeAmount;
-      const token1Amt = isToken1
-        ? postFeeAmount
-        : new Web3Number(0, token0Info.decimals);
+      const isRewardTokenMatch = claim.token.eq(poolKey.token0) || claim.token.eq(poolKey.token1);
+      if (isRewardTokenMatch) {
+        const _callsFinal = await this._handleRewardAndVaultTokenMatchHarvest({
+          acc,
+          claim,
+          isToken1,
+          token0Info,
+          token1Info,
+          postFeeAmount,
+          poolKey,
+          bounds,
+          maxIterations,
+          priceRatioPrecision,
+        });
+        calls.push(..._callsFinal);
+      } else {
+        const _callsFinal = await this._handleRewardAndVaultTokenMismatchHarvest({
+          claim,
+          token0Info,
+          token1Info,
+          postFeeAmount,
+          poolKey,
+          bounds,
+          maxIterations,
+          priceRatioPrecision,
+          acc,
+        });
+        calls.push(..._callsFinal);
+      }
+    }
+    return calls;
+  }
+
+  /**
+   * @description This funciton requires atleast one of the pool tokens to be reward token
+   * i.e. STRK. 
+   * @param params 
+   */
+  async _handleRewardAndVaultTokenMatchHarvest(params: {
+    claim: HarvestInfo;
+    isToken1: boolean;
+    token0Info: TokenInfo;
+    token1Info: TokenInfo;
+    postFeeAmount: Web3Number;
+    poolKey: EkuboPoolKey;
+    bounds: EkuboBounds;
+    maxIterations: number;
+    priceRatioPrecision: number;
+    acc: Account;
+  }) {
+    const { acc, claim, isToken1, token0Info, token1Info, postFeeAmount, poolKey, bounds, maxIterations, priceRatioPrecision } = params;
+    const token0Amt = isToken1
+      ? new Web3Number(0, token0Info.decimals)
+      : postFeeAmount;
+    const token1Amt = isToken1
+      ? postFeeAmount
+      : new Web3Number(0, token0Info.decimals);
+    logger.verbose(
+      `${
+        EkuboCLVault.name
+      }: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
+    );
+
+    // THis function cannot handle swapping of non-STRK pool,
+    // bcz atleast one of token0Amt or token1Amt are in STRK terms. 
+    const swapInfo = await this.getSwapInfoGivenAmounts(
+      poolKey,
+      token0Amt,
+      token1Amt,
+      bounds,
+      maxIterations,
+      priceRatioPrecision
+    );
+    swapInfo.token_to_address = token0Info.address.address;
+    logger.verbose(
+      `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+    );
+
+    logger.verbose(
+      `${EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+    );
+    const harvestEstimateCall = async (swapInfo1: SwapInfo) => {
+      const swap1Amount = Web3Number.fromWei(
+        uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
+        18 // cause its always STRK?
+      ).minimum(
+        postFeeAmount.toFixed(18) // cause always strk
+      ); // ensure we don't swap more than we have
+      swapInfo.token_from_amount = uint256.bnToUint256(swap1Amount.toWei());
+      swapInfo.token_to_min_amount = uint256.bnToUint256(
+        swap1Amount.multipliedBy(0).toWei() // placeholder
+      ); // 0.01% slippage
+
       logger.verbose(
-        `${
-          EkuboCLVault.name
-        }: harvest => token0Amt: ${token0Amt.toString()}, token1Amt: ${token1Amt.toString()}`
+        `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
       );
 
-      const swapInfo = await this.getSwapInfoGivenAmounts(
-        poolKey,
-        token0Amt,
-        token1Amt,
-        bounds,
-        maxIterations,
-        priceRatioPrecision
+      const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
+      logger.verbose(
+        `${EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
+      );
+      const swapInfo2 = {
+        ...swapInfo,
+        token_from_amount: uint256.bnToUint256(remainingAmount.toWei()),
+      };
+      swapInfo2.token_to_address = token1Info.address.address;
+      logger.verbose(
+        `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
+          swapInfo
+        )}`
       );
-      swapInfo.token_to_address = token0Info.address.address;
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(swapInfo)}`
+        `${EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
+          swapInfo2
+        )}`
       );
-
+      const calldata = [
+        claim.rewardsContract.address,
+        {
+          id: claim.claim.id,
+          amount: claim.claim.amount.toWei(),
+          claimee: claim.claim.claimee.address,
+        },
+        claim.proof.map((p) => num.getDecimalString(p)),
+        swapInfo,
+        swapInfo2,
+      ];
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+        `${EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
+          calldata
+        )}`
+      );
+      return [this.contract.populate("harvest", calldata)];
+    };
+    const _callsFinal = await this.rebalanceIter(
+      swapInfo,
+      acc,
+      harvestEstimateCall,
+      claim.token.eq(poolKey.token0),
+      0,
+      0n,
+      BigInt(postFeeAmount.toWei()), // upper limit is the post fee amount
+    );
+    logger.verbose(
+      `${EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(
+        _callsFinal
+      )}`
+    );
+
+    return _callsFinal;
+  }
+
+  /**
+   * @description This function handles harvesting of reward token that is not the same as any of the vault token
+   * i.e. STRK is not part of vault tokens like BTC/ETH 
+   * @param params 
+   * @returns 
+   */
+  async _handleRewardAndVaultTokenMismatchHarvest(params: {
+    claim: HarvestInfo;
+    token0Info: TokenInfo;
+    token1Info: TokenInfo;
+    postFeeAmount: Web3Number;
+    poolKey: EkuboPoolKey;
+    bounds: EkuboBounds;
+    maxIterations: number;
+    priceRatioPrecision: number;
+    acc: Account;
+  }) {
+    const { acc, claim, token0Info, token1Info, postFeeAmount, poolKey, bounds, maxIterations, priceRatioPrecision } = params;
+    let token0Amt = postFeeAmount;
+
+    // receiver of output swap tokens (vault itself)
+    const beneficiary = this.address.address;
+    let harvestCall: Call | null = null;
+
+    /**
+     *  Approach: Use binary search to decide the optimal split of reward
+     *  such that the output tokens can be used for exact liquidity addition
+     */
+    harvestCall = await this.harvestMismatchEstimateCallFn({
+      postFeeAmount,
+      claim,
+      token0Info,
+      token1Info,
+      acc,
+    });
+    if (!harvestCall) {
+      throw new Error("Harvest call not found");
+    }
+
+    return [harvestCall];
+  }
+
+  // given an amount (i.e. portion of reward to use to swap to token0), returns info on increasing or decreasing 
+  // amount for binary search
+  async harvestMismatchEstimateCallFn(params: {
+    postFeeAmount: Web3Number;
+    claim: HarvestInfo;
+    token0Info: TokenInfo;
+    token1Info: TokenInfo;
+    acc: Account;
+  }) {
+    const { postFeeAmount, claim, token0Info, token1Info, acc } = params;
+    let harvestCall: Call | null = null;
+
+    const binarySearchCallbackFn = async (mid: bigint) => {
+      const rewardPart2 = BigInt(postFeeAmount.toWei()) - mid;
+      const avnuWrapper = new AvnuWrapper();
+      const beneficiary = this.address.address;
+
+      // get quote for 1st part
+      const quote1 = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token0Info.address.address,
+        mid.toString(),
+        beneficiary
+      );
+      // default min amount is ok
+      const swapInfo1 = await avnuWrapper.getSwapInfo(
+        quote1,
+        beneficiary,
+        0,
+        beneficiary
       );
-      const harvestEstimateCall = async (swapInfo1: SwapInfo) => {
-        const swap1Amount = Web3Number.fromWei(
-          uint256.uint256ToBN(swapInfo1.token_from_amount).toString(),
-          18 // cause its always STRK?
-        ).minimum(
-          postFeeAmount.toFixed(18) // cause always strk
-        ); // ensure we don't swap more than we have
-        swapInfo.token_from_amount = uint256.bnToUint256(swap1Amount.toWei());
-        swapInfo.token_to_min_amount = uint256.bnToUint256(
-          swap1Amount.multipliedBy(0).toWei() // placeholder
-        ); // 0.01% slippage
 
-        logger.verbose(
-          `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
-        );
+      // get quote for 2nd part
+      const quote2 = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        rewardPart2.toString(),
+        beneficiary
+      );
+      // default min amount is ok
+      const swapInfo2 = await avnuWrapper.getSwapInfo(
+        quote2,
+        beneficiary,
+        0,
+        beneficiary
+      );
 
-        const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
-        logger.verbose(
-          `${EkuboCLVault.name}: harvest => remainingAmount: ${remainingAmount}`
-        );
-        const swapInfo2 = {
-          ...swapInfo,
-          token_from_amount: uint256.bnToUint256(remainingAmount.toWei()),
-        };
-        swapInfo2.token_to_address = token1Info.address.address;
-        logger.verbose(
-          `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-            swapInfo
-          )}`
-        );
-        logger.verbose(
-          `${EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
-            swapInfo2
-          )}`
-        );
+      // estimate the harvest using this swap info
+      try {
         const calldata = [
           claim.rewardsContract.address,
           {
@@ -1664,33 +1837,28 @@ export class EkuboCLVault extends BaseStrategy<
             claimee: claim.claim.claimee.address,
           },
           claim.proof.map((p) => num.getDecimalString(p)),
-          swapInfo,
+          swapInfo1,
           swapInfo2,
         ];
-        logger.verbose(
-          `${EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
-            calldata
-          )}`
-        );
-        return [this.contract.populate("harvest", calldata)];
-      };
-      const _callsFinal = await this.rebalanceIter(
-        swapInfo,
-        acc,
-        harvestEstimateCall,
-        claim.token.eq(poolKey.token0),
-        0,
-        0n,
-        BigInt(postFeeAmount.toWei()), // upper limit is the post fee amount
-      );
-      logger.verbose(
-        `${EkuboCLVault.name}: harvest => _callsFinal: ${JSON.stringify(
-          _callsFinal
-        )}`
-      );
-      calls.push(..._callsFinal);
+        harvestCall = this.contract.populate("harvest", calldata)
+        const gas = await acc.estimateInvokeFee(harvestCall);
+        return 'found';
+      } catch (err: any) {
+        if (err.message.includes('invalid token0 amount')) {
+          // too much token0 amount left, may be swap less to token0
+          return 'go_low';
+        } else if (err.message.includes('invalid token1 amount')) {
+          // too much token1 balance left, may be swap more to token0
+          return 'go_high';
+        }
+        return 'retry';
+      }
     }
-    return calls;
+
+    // run the binary search
+    await binarySearch(0n, BigInt(postFeeAmount.toWei()), binarySearchCallbackFn);
+   
+    return harvestCall;
   }
 
   async getInvestmentFlows() {