@strkfarm/sdk 1.1.38 → 1.1.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.38",
+  "version": "1.1.40",
   "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;
@@ -1592,70 +1593,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}`
       );
-      swapInfo.token_to_address = token0Info.address.address;
+      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)}`
+        `${EkuboCLVault.name}: harvest => swapInfo: ${JSON.stringify(
+          swapInfo
+        )}`
       );
-
       logger.verbose(
-        `${EkuboCLVault.name}: harvest => claim: ${JSON.stringify(claim)}`
+        `${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 => 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 +1844,29 @@ 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) {
+        console.error(err);
+        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() {

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -1,6 +1,8 @@
 import { Call, hash, num, shortString } from "starknet";
 import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
-import { ContractAddr } from "@/dataTypes";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
 import { LeafData } from "@/utils";
 import { CacheClass } from "@/utils/cacheClass";
 
@@ -15,10 +17,96 @@ export interface ManageCall {
 
 export type GenerateCallFn<T> = (params: T) => ManageCall;
 export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
+// export type GenerateCallFn<T> = (params: T) => ManageCall[];
+// export type AdapterLeafType<T> = {leaves: LeafData[], callConstructor: GenerateCallFn<T>}
 export type LeafAdapterFn<T> = () => AdapterLeafType<T>;
 
-export class BaseAdapter extends CacheClass {
+export enum APYType {
+  BASE = "base",
+  REWARD = "reward",
+  LST = "lst"
+}
+
+export interface SupportedPosition {
+  asset: TokenInfo,
+  isDebt: boolean
+}
+
+export interface BaseAdapterConfig {
+  baseToken: TokenInfo,
+  supportedPositions: SupportedPosition[],
+  networkConfig: IConfig,
+  pricer: PricerBase,
+  vaultAllocator: ContractAddr
+  vaultAddress: ContractAddr
+}
+
+export type PositionAPY = { apy: number, type: APYType };
+export type PositionInfo = {
+  amount: Web3Number,
+  usdValue: number,
+  remarks?: string,
+  apy: PositionAPY
+};
+
+// export abstract class BaseAdapter<T1, T2> extends CacheClass {
+  export abstract class BaseAdapter extends CacheClass {
+
+  // readonly config: BaseAdapterConfig;
+
+  // constructor(config: BaseAdapterConfig) {
+  //   super();
+  //   this.config = config;
+  // }
+
+  constructor() {
+    super();
+  }
+
+  // /**
+  //  * Loop through all supported positions and return amount, usd value, remarks and apy for each
+  //  */
+  // async getPositions(): Promise<PositionInfo[]> {
+  //   const results: PositionInfo[] = [];
+  //   for (const supported of this.config.supportedPositions) {
+  //     const amount = await this.getPosition(supported);
+  //     const usdValue = await this.getUSDValue(supported.asset, amount);
+  //     const apy = await this.getAPY(supported);
+  //     results.push({ amount, usdValue, apy });
+  //   }
+  //   return results;
+  // }
 
+  // /**
+  //  * Implemented by child adapters to compute APY for a given supported position
+  //  */
+  // protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+
+  // /**
+  //  * Implemented by child adapters to fetch amount for a given supported position
+  //  */
+  // protected abstract getPosition(supportedPosition: SupportedPosition): Promise<Web3Number>;
+
+  // /**
+  //  * Implemented by child adapters to calculate maximum deposit positions
+  //  * @param amount Optional amount in baseToken to deposit
+  //  */
+  // protected abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo[]>;
+
+  // /**
+  //  * Implemented by child adapters to calculate maximum withdraw positions
+  //  */
+  // protected abstract maxWithdraw(): Promise<PositionInfo[]>;
+
+  // /**
+  //  * Uses pricer to convert an amount of an asset to USD value
+  //  */
+  // protected async getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number> {
+  //   const priceInfo = await this.config.pricer.getPrice(asset.symbol);
+  //   return amount.toNumber() * priceInfo.price;
+  // }
+
+  
   protected constructSimpleLeafData(params: {
     id: string,
     target: ContractAddr,
@@ -38,4 +126,98 @@ export class BaseAdapter extends CacheClass {
       ]
     };
   }
+
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+  //  */
+  // protected abstract _getDepositLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+  //  */
+  // protected abstract _getWithdrawLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+
+  // /**
+  //  * Returns deposit leaf adapter using configured proof id
+  //  */
+  // getDepositLeaf(): AdapterLeafType<T1> {
+  //   const leafConfigs = this._getDepositLeaf();
+  //   const leaves = leafConfigs.map(config => {
+  //     const { target, method, packedArguments, sanitizer, id } = config;
+  //     const leaf = this.constructSimpleLeafData({
+  //       id: id,
+  //       target,
+  //       method,
+  //       packedArguments
+  //     }, sanitizer);
+  //     return leaf;
+  //   });
+  //   return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<T1> };
+  // }
+
+  // /**
+  //  * Returns withdraw leaf adapter using configured proof id
+  //  */
+  // getWithdrawLeaf(): AdapterLeafType<T2> {
+  //   const leafConfigs = this._getWithdrawLeaf();
+  //   const leaves = leafConfigs.map(config => {
+  //     const { target, method, packedArguments, sanitizer, id } = config;
+  //     const leaf = this.constructSimpleLeafData({
+  //       id: id,
+  //       target,
+  //       method,
+  //       packedArguments
+  //     }, sanitizer ?? SIMPLE_SANITIZER);
+  //     return leaf;
+  //   });
+  //   return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<T2> };
+  // }
+
+  // /**
+  //  * Default deposit callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getDepositCall<T1 = bigint[]>(params: T1): ManageCall[] {
+  //   const leafConfigs = this._getDepositLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
+
+  // /**
+  //  * Default withdraw callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getWithdrawCall<T2 = bigint[]>(params: T2): ManageCall[] {
+  //   const leafConfigs = this._getWithdrawLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
 }