@strkfarm/sdk 1.0.55 → 1.0.56

package/src/strategies/universal-strategy.ts

@@ -0,0 +1,543 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { BaseStrategy, SingleActionAmount, SingleTokenInfo } from "./base-strategy";
+import { PricerBase } from "@/modules/pricerBase";
+import { getNoRiskTags, IConfig, IStrategyMetadata, Protocols, RiskFactor, RiskType, VaultPosition } from "@/interfaces";
+import { Call, CallData, Contract, num, uint256 } from "starknet";
+import { VesuRebalanceSettings } from "./vesu-rebalance";
+import { assert, LeafData, logger, StandardMerkleTree } from "@/utils";
+import UniversalVaultAbi from '../data/universal-vault.abi.json';
+import ManagerAbi from '../data/vault-manager.abi.json';
+import { ApproveCallParams, BaseAdapter, CommonAdapter, FlashloanCallParams, GenerateCallFn, LeafAdapterFn, ManageCall, VesuAdapter, VesuModifyPositionCallParams, VesuPools } from "./universal-adapters";
+import { Global } from "@/global";
+
+export interface UniversalStrategySettings {
+  manager: ContractAddr,
+  vaultAllocator: ContractAddr,
+  redeemRequestNFT: ContractAddr,
+  leafAdapters: LeafAdapterFn<any>[],
+  adapters: {id: string, adapter: BaseAdapter}[]
+}
+
+
+export class UniversalStrategy<
+  S extends UniversalStrategySettings
+> extends BaseStrategy<
+  SingleTokenInfo,
+  SingleActionAmount
+> {
+
+  /** Contract address of the strategy */
+  readonly address: ContractAddr;
+  /** Pricer instance for token price calculations */
+  readonly pricer: PricerBase;
+  /** Metadata containing strategy information */
+  readonly metadata: IStrategyMetadata<S>;
+  /** Contract instance for interacting with the strategy */
+  readonly contract: Contract;
+  readonly managerContract: Contract;
+  merkleTree: StandardMerkleTree | undefined;
+
+  constructor(
+      config: IConfig,
+      pricer: PricerBase,
+      metadata: IStrategyMetadata<S>
+    ) {
+      super(config);
+      this.pricer = pricer;
+  
+      assert(
+        metadata.depositTokens.length === 1,
+        "VesuRebalance only supports 1 deposit token"
+      );
+      this.metadata = metadata;
+      this.address = metadata.address;
+  
+      this.contract = new Contract(
+        UniversalVaultAbi,
+        this.address.address,
+        this.config.provider
+      );
+      this.managerContract = new Contract(
+        ManagerAbi,
+        this.metadata.additionalInfo.manager.address,
+        this.config.provider
+      );
+  }
+
+  getMerkleTree() {
+    if (this.merkleTree) return this.merkleTree;
+    const leaves = this.metadata.additionalInfo.leafAdapters.map((adapter, index) => {
+      return adapter()
+    });
+    const standardTree = StandardMerkleTree.of(leaves.map(l => l.leaf));
+    this.merkleTree = standardTree;
+    return standardTree;
+  }
+
+  getMerkleRoot() {
+    return this.getMerkleTree().root;
+  }
+
+  getProofs<T>(id: string): { proofs: string[], callConstructor: GenerateCallFn<T> } {
+    const tree = this.getMerkleTree();
+    let proofs: string[] = [];
+    for (const [i, v] of tree.entries()) {
+      if (v.readableId == id) {
+        proofs = tree.getProof(i);
+      }
+    }
+    if (proofs.length === 0) {
+      throw new Error(`Proof not found for ID: ${id}`);
+    }
+
+    // find leaf adapter
+    const leafAdapter = this.metadata.additionalInfo.leafAdapters.find(adapter => adapter().leaf.readableId === id);
+    if (!leafAdapter) {
+      throw new Error(`Leaf adapter not found for ID: ${id}`);
+    }
+    const leafInfo = leafAdapter();
+    return {
+      proofs,
+      callConstructor: leafInfo.callConstructor.bind(leafInfo),
+    };
+  }
+
+  getAdapter(id: string): BaseAdapter {
+    const adapter = this.metadata.additionalInfo.adapters.find(adapter => adapter.id === id);
+    if (!adapter) {
+      throw new Error(`Adapter not found for ID: ${id}`);
+    }
+    return adapter.adapter;
+  }
+
+  asset() {
+    return this.metadata.depositTokens[0];
+  }
+
+  async depositCall(amountInfo: SingleActionAmount, receiver: ContractAddr): Promise<Call[]> {
+    // Technically its not erc4626 abi, but we just need approve call
+    // so, its ok to use it
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Deposit token mismatch"
+    );
+    const assetContract = new Contract(
+      UniversalVaultAbi,
+      this.asset().address.address,
+      this.config.provider
+    );
+    const call1 = assetContract.populate("approve", [
+      this.address.address,
+      uint256.bnToUint256(amountInfo.amount.toWei())
+    ]);
+    const call2 = this.contract.populate("deposit", [
+      uint256.bnToUint256(amountInfo.amount.toWei()),
+      receiver.address
+    ]);
+    return [call1, call2];
+  }
+
+  /**
+   * Calculates the Total Value Locked (TVL) for a specific user.
+   * @param user - Address of the user
+   * @returns Object containing the amount in token units and USD value
+   */
+  async getUserTVL(user: ContractAddr) {
+    const shares = await this.contract.balanceOf(user.address);
+    const assets = await this.contract.convert_to_assets(
+      uint256.bnToUint256(shares)
+    );
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
+  /**
+   * Calculates the weighted average APY across all pools based on USD value.
+   * @returns {Promise<number>} The weighted average APY across all pools
+   */
+  async netAPY(): Promise<number> {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const pools = await VesuAdapter.getVesuPools();
+    const pool1 = pools.pools.find(p => vesuAdapter1.config.poolId.eqString(num.getHexString(p.id)));
+    const pool2 = pools.pools.find(p => vesuAdapter2.config.poolId.eqString(num.getHexString(p.id)));
+    if (!pool1 || !pool2) {
+      throw new Error('Pool not found');
+    };
+    const collateralAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.collateral.symbol)?.stats!;
+    const debtAsset1 = pool1.assets.find((a: any) => a.symbol === vesuAdapter1.config.debt.symbol)?.stats!;
+    const collateralAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.collateral.symbol)?.stats!;
+    const debtAsset2 = pool2.assets.find((a: any) => a.symbol === vesuAdapter2.config.debt.symbol)?.stats!;
+
+    // supplyApy: { value: '8057256029163289', decimals: 18 },
+    // defiSpringSupplyApr: { value: '46856062629264560', decimals: 18 },
+    // borrowApr: { value: '12167825982336000', decimals: 18 },
+    const collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18 + Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18;
+    const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
+    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18 + Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18;
+    const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
+
+    const apys = [collateral1APY, debt1APY, collateral2APY, debt2APY];
+    const positions = await this.getVaultPositions();
+    assert(positions.length == apys.length, "Positions and APYs length mismatch");
+    const weightedAPYs = positions.map((pos, i) => {
+      return pos.usdValue * apys[i] * (i % 2 == 0 ? 1 : -1);
+    });
+    const netPosition = positions.reduce((acc, val, index) => acc + val.usdValue * (index % 2 == 0 ? 1 : -1), 0);
+    const apy = weightedAPYs.reduce((acc, val) => acc + val, 0) / netPosition;
+    return apy;
+  }
+
+  /**
+     * Calculates the total TVL of the strategy.
+     * @returns Object containing the total amount in token units and USD value
+  */
+  async getTVL() {
+    const assets = await this.contract.total_assets();
+    const amount = Web3Number.fromWei(
+      assets.toString(),
+      this.metadata.depositTokens[0].decimals
+    );
+    let price = await this.pricer.getPrice(
+      this.metadata.depositTokens[0].symbol
+    );
+    const usdValue = Number(amount.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount,
+      usdValue
+    };
+  }
+
+  async getAUM(): Promise<SingleTokenInfo> {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const leg1AUM = await vesuAdapter1.getPositions(this.config);
+    const leg2AUM = await vesuAdapter2.getPositions(this.config);
+
+    const token1Price = await this.pricer.getPrice(vesuAdapter1.config.collateral.symbol);
+
+    const aumToken = leg1AUM[0].amount
+      .plus(leg2AUM[0].usdValue / token1Price.price)
+      .minus(leg1AUM[1].usdValue / token1Price.price)
+      .minus(leg2AUM[1].amount);
+      
+    return {
+      tokenInfo: this.asset(),
+      amount: aumToken,
+      usdValue: aumToken.multipliedBy(token1Price.price).toNumber()
+    }
+  }
+
+  getVesuAdapters() {
+    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as VesuAdapter;
+    vesuAdapter1.pricer = this.pricer;
+    vesuAdapter2.pricer = this.pricer;
+    
+    return [vesuAdapter1, vesuAdapter2];
+  }
+
+  async getVaultPositions(): Promise<VaultPosition[]> {
+    const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
+    const leg1Positions = await vesuAdapter1.getPositions(this.config);
+    const leg2Positions = await vesuAdapter2.getPositions(this.config);
+    return [...leg1Positions, ...leg2Positions];
+  }
+
+  getSetManagerCall(strategist: ContractAddr, root = this.getMerkleRoot()) {
+    return this.managerContract.populate('set_manage_root', [strategist.address, num.getHexString(root)]);
+  }
+  
+  getManageCall(proofIds: string[], manageCalls: ManageCall[]) {
+    assert(proofIds.length == manageCalls.length, 'Proof IDs and Manage Calls length mismatch');
+    return this.managerContract.populate('manage_vault_with_merkle_verification', {
+        proofs: proofIds.map(id => this.getProofs(id).proofs),
+        decoder_and_sanitizers: manageCalls.map(call => call.sanitizer.address),
+        targets: manageCalls.map(call => call.call.contractAddress.address),
+        selectors: manageCalls.map(call => call.call.selector),
+        calldatas: manageCalls.map(call => call.call.calldata), // Calldata[]
+    });
+  }
+  
+  getVesuModifyPositionCalls(params: {
+    isLeg1: boolean,
+    isDeposit: boolean,
+    depositAmount: Web3Number,
+    debtAmount: Web3Number
+  }) {
+      assert(params.depositAmount.gt(0) || params.debtAmount.gt(0), 'Either deposit or debt amount must be greater than 0');
+      // approve token
+      const isToken1 = params.isLeg1 == params.isDeposit; // XOR
+      const STEP1_ID = isToken1 ? UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1 :UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2;
+      const manage4Info = this.getProofs<ApproveCallParams>(STEP1_ID);
+      const approveAmount = params.isDeposit ? params.depositAmount : params.debtAmount;
+      const manageCall4 = manage4Info.callConstructor({
+          amount: approveAmount
+      })
+
+      // deposit and borrow or repay and withdraw
+      const STEP2_ID = params.isLeg1 ? UNIVERSAL_MANAGE_IDS.VESU_LEG1 : UNIVERSAL_MANAGE_IDS.VESU_LEG2;
+      const manage5Info = this.getProofs<VesuModifyPositionCallParams>(STEP2_ID);
+      const manageCall5 = manage5Info.callConstructor(VesuAdapter.getDefaultModifyPositionCallParams({
+          collateralAmount: params.depositAmount,
+          isAddCollateral: params.isDeposit,
+          debtAmount: params.debtAmount,
+          isBorrow: params.isDeposit
+      }))
+
+      const output = [{
+        proofs: manage5Info.proofs,
+        manageCall: manageCall5
+      }];
+      if (approveAmount.gt(0)) {
+        output.unshift({
+          proofs: manage4Info.proofs,
+          manageCall: manageCall4
+        })
+      }
+      return output;
+  }
+
+  getTag() {
+    return `${UniversalStrategy.name}:${this.metadata.name}`;
+  }
+
+  async getVesuMultiplyCall(params: {
+    isDeposit: boolean,
+    leg1DepositAmount: Web3Number
+  }) {
+    const vesuAdapter1 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG1) as VesuAdapter;
+    const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as VesuAdapter;
+    const leg1LTV = await vesuAdapter1.getLTVConfig(this.config);
+    const leg2LTV = await vesuAdapter2.getLTVConfig(this.config);
+    logger.verbose(`${this.getTag()}: LTVLeg1: ${leg1LTV}`);
+    logger.verbose(`${this.getTag()}: LTVLeg2: ${leg2LTV}`);
+
+    const token1Price = await this.pricer.getPrice(vesuAdapter1.config.collateral.symbol);
+    const token2Price = await this.pricer.getPrice(vesuAdapter2.config.collateral.symbol);
+    logger.verbose(`${this.getTag()}: Price${vesuAdapter1.config.collateral.symbol}: ${token1Price.price}`);
+    logger.verbose(`${this.getTag()}: Price${vesuAdapter2.config.collateral.symbol}: ${token2Price.price}`);
+
+    const TARGET_HF = 1.3;
+
+    const k1 = token1Price.price * leg1LTV  / token2Price.price / TARGET_HF;
+    const k2 = token1Price.price * TARGET_HF / token2Price.price / leg2LTV;
+
+    const borrow2Amount = new Web3Number(
+      params.leg1DepositAmount.multipliedBy(k1.toFixed(6)).dividedBy(k2 - k1).toFixed(6),
+      vesuAdapter2.config.debt.decimals
+    );
+    const borrow1Amount = new Web3Number(
+      borrow2Amount.multipliedBy(k2).toFixed(6),
+      vesuAdapter1.config.debt.decimals
+    );
+    logger.verbose(`${this.getTag()}:: leg1DepositAmount: ${params.leg1DepositAmount.toString()} ${vesuAdapter1.config.collateral.symbol}`);
+    logger.verbose(`${this.getTag()}:: borrow1Amount: ${borrow1Amount.toString()} ${vesuAdapter1.config.debt.symbol}`);
+    logger.verbose(`${this.getTag()}:: borrow2Amount: ${borrow2Amount.toString()} ${vesuAdapter2.config.debt.symbol}`);
+
+    const callSet1 = this.getVesuModifyPositionCalls({
+      isLeg1: true,
+      isDeposit: params.isDeposit,
+      depositAmount: params.leg1DepositAmount.plus(borrow2Amount),
+      debtAmount: borrow1Amount
+    });
+
+    const callSet2 = this.getVesuModifyPositionCalls({
+      isLeg1: false,
+      isDeposit: params.isDeposit,
+      depositAmount: borrow1Amount,
+      debtAmount: borrow2Amount
+    });
+
+    const allActions = [...callSet1.map(i => i.manageCall), ...callSet2.map(i => i.manageCall)];
+    const flashloanCalldata = CallData.compile([
+        [...callSet1.map(i => i.proofs), ...callSet2.map(i => i.proofs)],
+        allActions.map(i => i.sanitizer.address),
+        allActions.map(i => i.call.contractAddress.address),
+        allActions.map(i => i.call.selector),
+        allActions.map(i => i.call.calldata)
+    ])
+
+    // flash loan
+    const STEP1_ID = UNIVERSAL_MANAGE_IDS.FLASH_LOAN;
+    const manage1Info = this.getProofs<FlashloanCallParams>(STEP1_ID);
+    const manageCall1 = manage1Info.callConstructor({
+        amount: borrow2Amount,
+        data: flashloanCalldata.map(i => BigInt(i))
+    })
+    const manageCall = this.getManageCall([UNIVERSAL_MANAGE_IDS.FLASH_LOAN], [manageCall1]);
+    return manageCall;
+  }
+
+  async getRebalanceCall(params: {
+    isLeg1toLeg2: boolean,
+    amount: Web3Number
+  }) {
+    let callSet1 = this.getVesuModifyPositionCalls({
+      isLeg1: true,
+      isDeposit: params.isLeg1toLeg2,
+      depositAmount: Web3Number.fromWei(0, 0),
+      debtAmount: params.amount
+    });
+
+    let callSet2 = this.getVesuModifyPositionCalls({
+      isLeg1: false,
+      isDeposit: params.isLeg1toLeg2,
+      depositAmount: params.amount,
+      debtAmount: Web3Number.fromWei(0, 0)
+    });
+
+    if (params.isLeg1toLeg2) {
+      const manageCall = this.getManageCall([
+        UNIVERSAL_MANAGE_IDS.VESU_LEG1,
+        UNIVERSAL_MANAGE_IDS.VESU_LEG2
+      ], [...callSet1.map(i => i.manageCall), ...callSet2.map(i => i.manageCall)]);
+      return manageCall;
+    } else {
+      const manageCall = this.getManageCall([
+        UNIVERSAL_MANAGE_IDS.VESU_LEG2,
+        UNIVERSAL_MANAGE_IDS.VESU_LEG1
+      ], [...callSet2.map(i => i.manageCall), ...callSet1.map(i => i.manageCall)]);
+      return manageCall;
+    }
+  }
+}
+
+
+export enum UNIVERSAL_MANAGE_IDS {
+  FLASH_LOAN = 'flash_loan_init',
+  VESU_LEG1 = 'vesu_leg1',
+  VESU_LEG2 = 'vesu_leg2',
+  APPROVE_TOKEN1 = 'approve_token1',
+  APPROVE_TOKEN2 = 'approve_token2'
+}
+
+export enum UNIVERSAL_ADAPTERS {
+  COMMON = 'common_adapter',
+  VESU_LEG1 = 'vesu_leg1_adapter',
+  VESU_LEG2 = 'vesu_leg2_adapter'
+}
+
+function getLooperSettings(
+  token1Symbol: string,
+  token2Symbol: string,
+  vaultSettings: UniversalStrategySettings,
+  pool1: ContractAddr,
+  pool2: ContractAddr
+) {
+  const USDCToken = Global.getDefaultTokens().find(token => token.symbol === token1Symbol)!;
+  const ETHToken = Global.getDefaultTokens().find(token => token.symbol === token2Symbol)!;
+
+  const commonAdapter = new CommonAdapter({
+    manager: vaultSettings.manager,
+    asset: USDCToken.address,
+    id: UNIVERSAL_MANAGE_IDS.FLASH_LOAN
+  })
+  const vesuAdapterUSDCETH = new VesuAdapter({
+    poolId: pool1,
+    collateral: USDCToken,
+    debt: ETHToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: UNIVERSAL_MANAGE_IDS.VESU_LEG1
+  })
+  const vesuAdapterETHUSDC = new VesuAdapter({
+    poolId: pool2,
+    collateral: ETHToken,
+    debt: USDCToken,
+    vaultAllocator: vaultSettings.vaultAllocator,
+    id: UNIVERSAL_MANAGE_IDS.VESU_LEG2
+  })
+  vaultSettings.adapters.push(...[{
+    id: UNIVERSAL_ADAPTERS.COMMON,
+    adapter: commonAdapter
+  }, {
+    id: UNIVERSAL_ADAPTERS.VESU_LEG1,
+    adapter: vesuAdapterUSDCETH
+  }, {
+    id: UNIVERSAL_ADAPTERS.VESU_LEG2,
+    adapter: vesuAdapterETHUSDC
+  }])
+  vaultSettings.leafAdapters.push(commonAdapter.getFlashloanAdapter.bind(commonAdapter));
+  vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getModifyPosition.bind(vesuAdapterUSDCETH));
+  vaultSettings.leafAdapters.push(vesuAdapterETHUSDC.getModifyPosition.bind(vesuAdapterETHUSDC));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vesuAdapterUSDCETH.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN1).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, UNIVERSAL_MANAGE_IDS.APPROVE_TOKEN2).bind(commonAdapter));
+  return vaultSettings; 
+}
+
+const _riskFactor: RiskFactor[] = [
+  { type: RiskType.SMART_CONTRACT_RISK, value: 0.5, weight: 25, reason: "Audited by Zellic" },
+  { type: RiskType.LIQUIDATION_RISK, value: 1, weight: 50, reason: "Liquidation risk is mitigated btable price feed on Starknet" }
+];
+
+const usdcVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07'),
+  vaultAllocator: ContractAddr.from('0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba'),
+  redeemRequestNFT: ContractAddr.from('0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda'),
+  leafAdapters: [],
+  adapters: []
+}
+
+const wbtcVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34'),
+  vaultAllocator: ContractAddr.from('0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735'),
+  redeemRequestNFT: ContractAddr.from('0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2'),
+  leafAdapters: [],
+  adapters: []
+}
+
+export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =
+  [
+    {
+      name: "USDC Evergreen",
+      description: "A universal strategy for managing USDC assets",
+      address: ContractAddr.from('0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDC')!],
+      additionalInfo: getLooperSettings('USDC', 'ETH', usdcVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      risk: {
+        riskFactor: _riskFactor,
+        netRisk:
+          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor)
+      },
+      protocols: [Protocols.VESU],
+      maxTVL: Web3Number.fromWei(0, 6),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+    {
+      name: "WBTC Evergreen",
+      description: "A universal strategy for managing WBTC assets",
+      address: ContractAddr.from('0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'WBTC')!],
+      additionalInfo: getLooperSettings('WBTC', 'ETH', wbtcVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+      risk: {
+        riskFactor: _riskFactor,
+        netRisk:
+          _riskFactor.reduce((acc, curr) => acc + curr.value * curr.weight, 0) /
+          _riskFactor.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor)
+      },
+      protocols: [Protocols.VESU],
+      maxTVL: Web3Number.fromWei(0, 8),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+  ]

package/src/utils/index.ts

@@ -1,4 +1,5 @@
 export * from '@/utils/logger';
+export * from './oz-merkle';
 
 // Utility type to make all optional properties required
 export type RequiredFields<T> = {

package/src/utils/oz-merkle.ts

@@ -0,0 +1,100 @@
+import { BytesLike, HexString, toHex } from "@ericnordelo/strk-merkle-tree/dist/bytes";
+import { MultiProof, processMultiProof, processProof } from "@ericnordelo/strk-merkle-tree/dist/core";
+import { standardLeafHash } from "@ericnordelo/strk-merkle-tree/dist/hashes";
+import { MerkleTreeData, MerkleTreeImpl } from "@ericnordelo/strk-merkle-tree/dist/merkletree";
+import { MerkleTreeOptions } from "@ericnordelo/strk-merkle-tree/dist/options";
+import { ValueType } from "@ericnordelo/strk-merkle-tree/dist/serde";
+import { validateArgument } from "@ericnordelo/strk-merkle-tree/src/utils/errors";
+import { num } from "starknet";
+import * as starknet from "@scure/starknet";
+
+export interface LeafData {
+  id: bigint,
+  readableId: string,
+  data: bigint[]
+}
+
+function hash_leaf(leaf: LeafData) {
+  if (leaf.data.length < 1) {
+    throw new Error("Invalid leaf data");
+  }
+  let firstElement = leaf.data[0];
+  let value = firstElement;
+  for (let i=1; i < leaf.data.length; i++) {
+    value = pedersen_hash(value, leaf.data[i]);
+  }
+  return `0x${num.toHexString(value).replace(/^0x/, '').padStart(64, '0')}`;
+}
+
+function pedersen_hash(a: bigint, b: bigint): bigint {
+  return BigInt(starknet.pedersen(a, b).toString());
+}
+
+
+export interface StandardMerkleTreeData<T extends any> extends MerkleTreeData<T> {
+  format: 'standard-v1';
+  leafEncoding: ValueType[];
+}
+
+export class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
+  protected constructor(
+    protected readonly tree: HexString[],
+    protected readonly values: StandardMerkleTreeData<LeafData>['values'],
+    protected readonly leafEncoding: ValueType[],
+  ) {
+    super(tree, values, leaf => {
+      return hash_leaf(leaf)
+    });
+  }
+
+  static of(
+    values: LeafData[],
+    leafEncoding: ValueType[] = [],
+    options: MerkleTreeOptions = {},
+  ): StandardMerkleTree {
+    // use default nodeHash (standardNodeHash)
+    const [tree, indexedValues] = MerkleTreeImpl.prepare(values, options, leaf => {
+      return hash_leaf(leaf)
+    });
+    return new StandardMerkleTree(tree, indexedValues, leafEncoding);
+  }
+
+  static load(data: StandardMerkleTreeData<LeafData>): StandardMerkleTree {
+    validateArgument(data.format === 'standard-v1', `Unknown format '${data.format}'`);
+    validateArgument(data.leafEncoding !== undefined, 'Expected leaf encoding');
+
+    const tree = new StandardMerkleTree(data.tree, data.values, data.leafEncoding);
+    tree.validate();
+    return tree;
+  }
+
+  static verify<T extends any[]>(root: BytesLike, leafEncoding: ValueType[], leaf: T, proof: BytesLike[]): boolean {
+    // use default nodeHash (standardNodeHash) for processProof
+    return toHex(root) === processProof(standardLeafHash(leafEncoding, leaf), proof);
+  }
+
+  static verifyMultiProof<T extends any[]>(
+    root: BytesLike,
+    leafEncoding: ValueType[],
+    multiproof: MultiProof<BytesLike, T>,
+  ): boolean {
+    // use default nodeHash (standardNodeHash) for processMultiProof
+    return (
+      toHex(root) ===
+      processMultiProof({
+        leaves: multiproof.leaves.map(leaf => standardLeafHash(leafEncoding, leaf)),
+        proof: multiproof.proof,
+        proofFlags: multiproof.proofFlags,
+      })
+    );
+  }
+
+  dump(): StandardMerkleTreeData<LeafData> {
+    return {
+      format: 'standard-v1',
+      leafEncoding: this.leafEncoding,
+      tree: this.tree,
+      values: this.values,
+    };
+  }
+}