@strkfarm/sdk 1.1.50 → 1.1.51

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,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    // 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),

package/src/modules/harvests.ts

@@ -34,23 +34,30 @@ export class Harvests {
         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;
     }
 }

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/strategies/ekubo-cl-vault.tsx

@@ -1597,11 +1597,20 @@ export class EkuboCLVault extends BaseStrategy<
     };
   }
 
-  async harvest(acc: Account, maxIterations = 20, priceRatioPrecision = 4): Promise<Call[]> {
+  async harvest(acc: Account, maxIterations = 20, priceRatioPrecision = 4, minRewardAmount: Web3Number = new Web3Number(0, 18)): Promise<Call[]> {
     const ekuboHarvests = new EkuboHarvests(this.config);
-    const unClaimedRewards = await ekuboHarvests.getUnHarvestedRewards(
+    
+    // get unclaimed rewards and filter out those less than the minimum reward amount
+    const unClaimedRewards = (await ekuboHarvests.getUnHarvestedRewards(
       this.address
-    );
+    )).filter(claim => claim.actualReward.greaterThanOrEqualTo(minRewardAmount));
+
+    if (unClaimedRewards.length == 0) {
+      logger.verbose(`${EkuboCLVault.name}: harvest => no unclaimed rewards found`);
+      return [];
+    }
+
+    // get necessary info for the harvest
     const poolKey = await this.getPoolKey();
     const token0Info = await Global.getTokenInfoFromAddr(poolKey.token0);
     const token1Info = await Global.getTokenInfoFromAddr(poolKey.token1);
@@ -1609,8 +1618,14 @@ export class EkuboCLVault extends BaseStrategy<
     logger.verbose(
       `${EkuboCLVault.name}: harvest => unClaimedRewards: ${unClaimedRewards.length}`
     );
+
+    // execute the harvest
     const calls: Call[] = [];
-    for (let claim of unClaimedRewards) {
+    // do one at a time. 
+    const chosenClaim = unClaimedRewards[0];
+    logger.info(`${EkuboCLVault.name}: harvest => doing one at a time`);
+    logger.info(`${EkuboCLVault.name}: harvest => chosenClaim -> Claim ID: ${chosenClaim.claim.id}, Amount: ${chosenClaim.claim.amount.toString()}, actualAmount: ${chosenClaim.actualReward.toString()}, addr: ${chosenClaim.claim.claimee.toString()}`);
+    for (let claim of [chosenClaim]) {
       const fee = claim.claim.amount
         .multipliedBy(this.metadata.additionalInfo.feeBps)
         .dividedBy(10000);
@@ -1683,60 +1698,50 @@ export class EkuboCLVault extends BaseStrategy<
     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)}`
+      }: harvest => token0Amt: ${token0Amt.toFixed(18)}, token1Amt: ${token1Amt.toFixed(18)}`
     );
 
     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?
+    const claimTokenInfo = await Global.getTokenInfoFromAddr(claim.token);
+    const harvestEstimateCall = async (baseSwapInfo: SwapInfo) => {
+      // - the base swap if actual swap from claim token to non-claim token
+      // - the other swap is just claim token to claim token (e.g. STRK to STRK)
+      // which is just dummy
+      let baseSwapAmount = Web3Number.fromWei(
+        uint256.uint256ToBN(baseSwapInfo.token_from_amount).toString(),
+        claimTokenInfo.decimals
       ).minimum(
-        postFeeAmount.toFixed(18) // cause always strk
+        postFeeAmount.toFixed(claimTokenInfo.decimals)
       ); // 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
+      if (baseSwapAmount.lt(0.0001)) {
+        baseSwapAmount = new Web3Number(0, claimTokenInfo.decimals);
+      }
+      baseSwapInfo.token_from_amount = uint256.bnToUint256(baseSwapAmount.toWei());
 
+      const isToken0ClaimToken = claim.token.eq(poolKey.token0);
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swap1Amount: ${swap1Amount}`
+        `${EkuboCLVault.name}: harvest => isToken0ClaimToken: ${isToken0ClaimToken}, baseSwapAmount: ${baseSwapAmount}`
       );
 
-      const remainingAmount = postFeeAmount.minus(swap1Amount).maximum(0);
+      const remainingAmount = postFeeAmount.minus(baseSwapAmount).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;
+
+      // obv, same to same
+      let dummySwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, claim.token);
+      dummySwapInfo.token_from_amount = uint256.bnToUint256(remainingAmount.toWei());
+
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
-          swapInfo
+        `${EkuboCLVault.name}: harvest => dummySwapInfo: ${JSON.stringify(
+          dummySwapInfo
         )}`
       );
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => swapInfo2: ${JSON.stringify(
-          swapInfo2
+        `${EkuboCLVault.name}: harvest => baseSwapInfo: ${JSON.stringify(
+          baseSwapInfo
         )}`
       );
       const calldata = [
@@ -1747,18 +1752,41 @@ export class EkuboCLVault extends BaseStrategy<
           claimee: claim.claim.claimee.address,
         },
         claim.proof.map((p) => num.getDecimalString(p)),
-        swapInfo,
-        swapInfo2,
+        isToken0ClaimToken ? dummySwapInfo : baseSwapInfo, // is token0 claim token, its just dummy swap
+        isToken0ClaimToken ? baseSwapInfo : dummySwapInfo,
       ];
-      logger.verbose(
-        `${EkuboCLVault.name}: harvest => calldata: ${JSON.stringify(
-          calldata
-        )}`
-      );
       return [this.contract.populate("harvest", calldata)];
     };
+
+    // if token0 == claim token, then the base swapInfo is from claim token to token1
+    // if token1 == claim token, then the base swapInfo is from claim token to token0
+    const isToken0ClaimToken = claim.token.eq(poolKey.token0);
+    let baseSwapInfo = AvnuWrapper.buildZeroSwap(claim.token, this.address.address, isToken0ClaimToken ? token1Info.address : token0Info.address);
+    baseSwapInfo.token_from_amount = uint256.bnToUint256(postFeeAmount.toWei()); // we try to swap all to start with
+   
+    // if token0 != claim token, then we swap from claim token to token0
+    if (postFeeAmount.greaterThan(0) && !isToken0ClaimToken) {
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token0Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    } else if (postFeeAmount.greaterThan(0) && isToken0ClaimToken) {
+      // if token0 == claim token, then we swap from claim token to token1
+      const avnuWrapper = new AvnuWrapper();
+      const quote = await avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        postFeeAmount.toWei(),
+        this.address.address
+      );
+      baseSwapInfo = await avnuWrapper.getSwapInfo(quote, this.address.address, 0, this.address.address);
+    }
     const _callsFinal = await this.rebalanceIter(
-      swapInfo,
+      baseSwapInfo,
       acc,
       harvestEstimateCall,
       claim.token.eq(poolKey.token0),
@@ -1828,39 +1856,47 @@ export class EkuboCLVault extends BaseStrategy<
   }) {
     const { postFeeAmount, claim, token0Info, token1Info, acc } = params;
     let harvestCall: Call | null = null;
+    logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => postFeeAmount: ${postFeeAmount.toString()}`);
 
+    let attempt = 0;
+    let MAX_ATTEMPTS = 50;
     const binarySearchCallbackFn = async (mid: bigint) => {
+      attempt++;
+      logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => mid: ${mid}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
       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(
+      const quote1Prom = avnuWrapper.getQuotes(
         claim.token.address,
         token0Info.address.address,
         mid.toString(),
         beneficiary
       );
+      const quote2Prom = avnuWrapper.getQuotes(
+        claim.token.address,
+        token1Info.address.address,
+        rewardPart2.toString(),
+        beneficiary
+      );
+      const [quote1, quote2] = await Promise.all([quote1Prom, quote2Prom]);
+      
       // default min amount is ok
       const swapInfo1 = await avnuWrapper.getSwapInfo(
         quote1,
         beneficiary,
-        0,
+        0, // fee bps
         beneficiary
       );
 
       // 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,
+        0, // fee bps
         beneficiary
       );
 
@@ -1879,15 +1915,19 @@ export class EkuboCLVault extends BaseStrategy<
         ];
         harvestCall = this.contract.populate("harvest", calldata)
         const gas = await acc.estimateInvokeFee(harvestCall);
+        logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => gas: ${gas.overall_fee.toString()}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return 'found';
       } catch (err: any) {
         if (err.message.includes('invalid token0 amount')) {
+          logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token0 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           // too much token0 amount left, may be swap less to token0
           return 'go_low';
         } else if (err.message.includes('invalid token1 amount')) {
+          logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => invalid token1 amount, attempt: ${attempt}/${MAX_ATTEMPTS}`);
           // too much token1 balance left, may be swap more to token0
           return 'go_high';
         }
+        logger.verbose(`${EkuboCLVault.name}: harvestMismatchEstimateCallFn => error: ${err.message}, attempt: ${attempt}/${MAX_ATTEMPTS}`);
         return 'retry';
       }
     }