@strkfarm/sdk 1.0.56 → 1.0.58

package/src/strategies/universal-adapters/vesu-adapter.ts

@@ -55,7 +55,6 @@ export class VesuAdapter extends BaseAdapter {
   config: VesuAdapterConfig;
   networkConfig: IConfig | undefined;
   pricer: PricerBase | undefined;
-  cache: Record<string, any> = {};
 
   constructor(config: VesuAdapterConfig) {
     super();
@@ -121,17 +120,19 @@ export class VesuAdapter extends BaseAdapter {
       denomination: this.formatAmountDenominationEnum(params.collateralAmount.denomination),
       value: {
         abs: uint256.bnToUint256(params.collateralAmount.value.abs.toWei()),
-        is_negative: params.collateralAmount.value.is_negative
+        is_negative: params.collateralAmount.value.abs.isZero() ? false: params.collateralAmount.value.is_negative
       }
     };
+    logger.verbose(`VesuAdapter::ConstructingModify::Collateral::${JSON.stringify(_collateral)}`)
     const _debt = {
       amount_type: this.formatAmountTypeEnum(params.debtAmount.amount_type),
       denomination: this.formatAmountDenominationEnum(params.debtAmount.denomination),
       value: {
         abs: uint256.bnToUint256(params.debtAmount.value.abs.toWei()),
-        is_negative: params.debtAmount.value.is_negative
+        is_negative: params.debtAmount.value.abs.isZero() ? false: params.debtAmount.value.is_negative
       }
     };
+    logger.verbose(`VesuAdapter::ConstructingModify::Debt::${JSON.stringify(_debt)}`)
     const singletonContract = new Contract(VesuSingletonAbi, this.VESU_SINGLETON.toString(), new RpcProvider({nodeUrl: ''}));
     const call = singletonContract.populate('modify_position', {
       params: {
@@ -182,13 +183,14 @@ export class VesuAdapter extends BaseAdapter {
 
   async getLTVConfig(config: IConfig) {
     const CACHE_KEY = 'ltv_config';
-    if (this.cache[CACHE_KEY]) {
-      return this.cache[CACHE_KEY] as number;
+    const cacheData = this.getCache<number>(CACHE_KEY);
+    if (cacheData) {
+      return cacheData as number;
     }
     const output: any = await this.getVesuSingletonContract(config)
       .call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address])
-    this.cache[CACHE_KEY] = Number(output.max_ltv) / 1e18;
-    return this.cache[CACHE_KEY] as number;
+    this.setCache(CACHE_KEY, Number(output.max_ltv) / 1e18, 300000); // ttl: 5min
+    return this.getCache<number>(CACHE_KEY) as number;
   }
 
   async getPositions(config: IConfig): Promise<VaultPosition[]> {
@@ -197,8 +199,9 @@ export class VesuAdapter extends BaseAdapter {
     }
     //  { '0': { collateral_shares: 0n, nominal_debt: 0n }, '1': 0n, '2': 0n }
     const CACHE_KEY = 'positions';
-    if (this.cache[CACHE_KEY]) {
-      return this.cache[CACHE_KEY];
+    const cacheData = this.getCache<VaultPosition[]>(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
     }
     const output: any = await this.getVesuSingletonContract(config)
       .call('position_unsafe', [
@@ -224,10 +227,77 @@ export class VesuAdapter extends BaseAdapter {
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
       remarks: "Debt"
     }];
-    this.cache[CACHE_KEY] = value;
+    this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
     return value;
   }
 
+  async getCollateralization(config: IConfig): Promise<Omit<VaultPosition, 'amount'>[]> {
+    if (!this.pricer) {
+      throw new Error('Pricer is not initialized');
+    }
+    //  { '0': bool, '1': 0n, '2': 0n }
+    const CACHE_KEY = 'collateralization';
+    const cacheData = this.getCache<Omit<VaultPosition, 'amount'>[]>(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
+    }
+    const output: any = await this.getVesuSingletonContract(config)
+      .call('check_collateralization_unsafe', [
+        this.config.poolId.address,
+        this.config.collateral.address.address,
+        this.config.debt.address.address,
+        this.config.vaultAllocator.address
+      ]);
+
+    // usd values
+    const collateralAmount = Web3Number.fromWei(output['1'].toString(), 18);
+    const debtAmount = Web3Number.fromWei(output['2'].toString(), 18);
+    const value = [{
+      token: this.config.collateral,
+      usdValue: collateralAmount.toNumber(),
+      remarks: "Collateral"
+    }, {
+      token: this.config.debt,
+      usdValue: debtAmount.toNumber(),
+      remarks: "Debt"
+    }];
+    this.setCache(CACHE_KEY, value, 60000); // ttl: 1min
+    return value;
+  }
+
+  async getAssetPrices() {
+    const collateralizationProm = this.getCollateralization(this.networkConfig!);
+    const positionsProm = this.getPositions(this.networkConfig!);
+    const ltvProm = this.getLTVConfig(this.networkConfig!);
+
+    const output = await Promise.all([collateralizationProm, positionsProm, ltvProm]);
+    const [collateralization, positions, ltv] = output;
+
+    const collateralTokenAmount = positions[0].amount;
+    const collateralUSDAmount = collateralization[0].usdValue;
+    const collateralPrice = collateralUSDAmount / collateralTokenAmount.toNumber();
+
+    const debtTokenAmount = positions[1].amount;
+    const debtUSDAmount = collateralization[1].usdValue;
+    const debtPrice = debtUSDAmount / debtTokenAmount.toNumber();
+    
+    return {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    }
+  }
+
+  async getHealthFactor() {
+    const ltv = await this.getLTVConfig(this.networkConfig!);
+    const collateralisation = await this.getCollateralization(this.networkConfig!);
+    return collateralisation[0].usdValue * ltv / collateralisation[1].usdValue;
+  }
+
   static async getVesuPools(
       retry = 0
     ): Promise<VesuPoolsInfo> {

package/src/strategies/universal-strategy.ts

@@ -9,13 +9,17 @@ 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";
+import { ERC20 } from "@/modules";
 
 export interface UniversalStrategySettings {
   manager: ContractAddr,
   vaultAllocator: ContractAddr,
   redeemRequestNFT: ContractAddr,
+  aumOracle: ContractAddr,
   leafAdapters: LeafAdapterFn<any>[],
-  adapters: {id: string, adapter: BaseAdapter}[]
+  adapters: {id: string, adapter: BaseAdapter}[],
+  targetHealthFactor: number,
+  minHealthFactor: number
 }
 
 
@@ -166,7 +170,7 @@ export class UniversalStrategy<
    * 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> {
+  async netAPY(): Promise<{ net: number, splits: { apy: number, id: string }[] }> {
     const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const pools = await VesuAdapter.getVesuPools();
     const pool1 = pools.pools.find(p => vesuAdapter1.config.poolId.eqString(num.getHexString(p.id)));
@@ -182,20 +186,32 @@ export class UniversalStrategy<
     // 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 collateral1APY = Number(collateralAsset1.supplyApy.value) / 1e18;
     const debt1APY = Number(debtAsset1.borrowApr.value) / 1e18;
-    const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18 + Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18;
+    const collateral2APY = Number(collateralAsset2.supplyApy.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;
+    const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
+    const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
+    assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
+    const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
+    const baseAPY = this.computeAPY(baseAPYs, weights);
+    const rewardAPY = this.computeAPY(rewardAPYs, weights);
+    const apys = [...baseAPYs, ...rewardAPYs];
+    const netAPY = baseAPY + rewardAPY;
+    return { net: netAPY, splits: [{
+      apy: baseAPY, id: 'base'
+    }, {
+      apy: rewardAPY, id: 'defispring'
+    }] };
+  }
+
+  private computeAPY(apys: number[], weights: number[]) {
+    assert(apys.length === weights.length, "APYs and weights length mismatch");
+    const weightedSum = apys.reduce((acc, apy, i) => acc + apy * weights[i], 0);
+    const totalWeight = weights.reduce((acc, weight) => acc + weight, 0);
+    return weightedSum / totalWeight;
   }
 
   /**
@@ -219,23 +235,56 @@ export class UniversalStrategy<
     };
   }
 
-  async getAUM(): Promise<SingleTokenInfo> {
+  async getAUM(): Promise<{net: SingleTokenInfo, prevAum: Web3Number, splits: {id: string, aum: Web3Number}[]}> {
+    const currentAUM: bigint = await this.contract.call('aum', []) as bigint;
+    const lastReportTime = await this.contract.call('last_report_timestamp', []);
+
+    const token1Price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+
+    // calculate actual aum
     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 balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    logger.verbose(`${this.getTag()} unused balance: ${balance}`);
 
     const aumToken = leg1AUM[0].amount
       .plus(leg2AUM[0].usdValue / token1Price.price)
       .minus(leg1AUM[1].usdValue / token1Price.price)
-      .minus(leg2AUM[1].amount);
-      
-    return {
+      .minus(leg2AUM[1].amount).plus(balance);
+    logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
+
+    // calculate estimated growth from strk rewards
+    const netAPY = await this.netAPY();
+    const defispringAPY = netAPY.splits.find(s => s.id === 'defispring')?.apy || 0;
+    if (!defispringAPY) throw new Error('DefiSpring APY not found');
+
+    const timeDiff = (Math.round(Date.now() / 1000) - Number(lastReportTime));
+    const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    const rewardAssets = prevAum.multipliedBy(growthRate);
+    logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
+    logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
+    logger.verbose(`${this.getTag()} Net APY: ${JSON.stringify(netAPY)}`);
+    logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
+
+    const newAUM = aumToken.plus(rewardAssets);
+    logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
+    
+    const net = {
       tokenInfo: this.asset(),
-      amount: aumToken,
-      usdValue: aumToken.multipliedBy(token1Price.price).toNumber()
-    }
+      amount: newAUM,
+      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
+    };
+    const splits = [{
+      id: 'finalised',
+      aum: aumToken
+    }, {
+      id: 'defispring',
+      aum: rewardAssets
+    }];
+    return { net, splits, prevAum };
   }
 
   getVesuAdapters() {
@@ -243,6 +292,8 @@ export class UniversalStrategy<
     const vesuAdapter2 = this.getAdapter(UNIVERSAL_ADAPTERS.VESU_LEG2) as VesuAdapter;
     vesuAdapter1.pricer = this.pricer;
     vesuAdapter2.pricer = this.pricer;
+    vesuAdapter1.networkConfig = this.config;
+    vesuAdapter2.networkConfig = this.config;
     
     return [vesuAdapter1, vesuAdapter2];
   }
@@ -297,12 +348,14 @@ export class UniversalStrategy<
 
       const output = [{
         proofs: manage5Info.proofs,
-        manageCall: manageCall5
+        manageCall: manageCall5,
+        step: STEP2_ID
       }];
       if (approveAmount.gt(0)) {
         output.unshift({
           proofs: manage4Info.proofs,
-          manageCall: manageCall4
+          manageCall: manageCall4,
+          step: STEP1_ID
         })
       }
       return output;
@@ -312,12 +365,114 @@ export class UniversalStrategy<
     return `${UniversalStrategy.name}:${this.metadata.name}`;
   }
 
+  async getVesuHealthFactors() {
+    return await Promise.all(this.getVesuAdapters().map(v => v.getHealthFactor()));
+  }
+
+  async computeRebalanceConditionAndReturnCalls(): Promise<Call[]> {
+    const vesuAdapters = this.getVesuAdapters();
+    const healthFactors = await this.getVesuHealthFactors();
+    const leg1HealthFactor = healthFactors[0];
+    const leg2HealthFactor = healthFactors[1];
+    logger.verbose(`${this.getTag()}: HealthFactorLeg1: ${leg1HealthFactor}`);
+    logger.verbose(`${this.getTag()}: HealthFactorLeg2: ${leg2HealthFactor}`);
+
+    const minHf = this.metadata.additionalInfo.minHealthFactor;
+    const isRebalanceNeeded1 = leg1HealthFactor < minHf;
+    const isRebalanceNeeded2 = leg2HealthFactor < minHf;
+    if (!isRebalanceNeeded1 && !isRebalanceNeeded2) {
+      return [];
+    }
+    
+    if (isRebalanceNeeded1) {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[0], leg1HealthFactor, false);
+      const leg2HF = await this.getNewHealthFactor(vesuAdapters[1], amount, true);
+      assert(leg2HF > minHf, `Rebalance Leg1 failed: Leg2 HF after rebalance would be too low: ${leg2HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: false,
+        amount: amount
+      })];
+    } else {
+      const amount = await this.getLegRebalanceAmount(vesuAdapters[1], leg2HealthFactor, true);
+      const leg1HF = await this.getNewHealthFactor(vesuAdapters[0], amount, false);
+      assert(leg1HF > minHf, `Rebalance Leg2 failed: Leg1 HF after rebalance would be too low: ${leg1HF}`);
+      return [await this.getRebalanceCall({
+        isLeg1toLeg2: true,
+        amount: amount
+      })];
+    }
+  }
+
+  private async getNewHealthFactor(vesuAdapter: VesuAdapter, newAmount: Web3Number, isWithdraw: boolean) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+
+    if (isWithdraw) {
+      const newHF = ((collateralTokenAmount.toNumber() - newAmount.toNumber()) * collateralPrice * ltv) / debtUSDAmount;
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isDeposit`);
+      return newHF;
+    } else { // is borrow
+      const newHF = (collateralUSDAmount * ltv) / ((debtTokenAmount.toNumber() + newAmount.toNumber()) * debtPrice);
+      logger.verbose(`getNewHealthFactor:: HF: ${newHF}, amoutn: ${newAmount.toNumber()}, isRepay`);
+      return newHF;
+    }
+  }
+
+  /**
+   * 
+   * @param vesuAdapter 
+   * @param currentHf 
+   * @param isDeposit if true, attempt by adding collateral, else by repaying
+   * @returns 
+   */
+  private async getLegRebalanceAmount(vesuAdapter: VesuAdapter, currentHf: number, isDeposit: boolean) {
+    const {
+      collateralTokenAmount,
+      collateralUSDAmount,
+      collateralPrice,
+      debtTokenAmount,
+      debtUSDAmount,
+      debtPrice,
+      ltv
+    } = await vesuAdapter.getAssetPrices();
+
+    // debt is zero, nothing to rebalance
+    if(debtTokenAmount.isZero()) {
+      return Web3Number.fromWei(0, 0);
+    }
+
+    assert(collateralPrice > 0 && debtPrice > 0, "getRebalanceAmount: Invalid price");
+
+    // avoid calculating for too close
+    const targetHF = this.metadata.additionalInfo.targetHealthFactor;
+    if (currentHf > targetHF - 0.01) 
+      throw new Error("getLegRebalanceAmount: Current health factor is healthy");
+
+    if (isDeposit) {
+      // TargetHF = (collAmount + newAmount) * price * ltv / debtUSD
+      const newAmount = targetHF * debtUSDAmount / (collateralPrice * ltv) - collateralTokenAmount.toNumber();
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: addCollateral, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), collateralTokenAmount.decimals);
+    } else {
+      // TargetHF = collUSD * ltv / (debtAmount - newAmount) * debtPrice
+      const newAmount =  debtTokenAmount.toNumber() - collateralUSDAmount * ltv / (targetHF * debtPrice);
+      logger.verbose(`${this.getTag()}:: getLegRebalanceAmount: repayDebt, currentHf: ${currentHf}, targetHF: ${targetHF}, collAmount: ${collateralTokenAmount.toString()}, collUSD: ${collateralUSDAmount}, collPrice: ${collateralPrice}, debtAmount: ${debtTokenAmount.toString()}, debtUSD: ${debtUSDAmount}, debtPrice: ${debtPrice}, ltv: ${ltv}, newAmount: ${newAmount}`);
+      return new Web3Number(newAmount.toFixed(8), debtTokenAmount.decimals);
+    }
+  }
+
   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 [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const leg1LTV = await vesuAdapter1.getLTVConfig(this.config);
     const leg2LTV = await vesuAdapter2.getLTVConfig(this.config);
     logger.verbose(`${this.getTag()}: LTVLeg1: ${leg1LTV}`);
@@ -328,7 +483,7 @@ export class UniversalStrategy<
     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 TARGET_HF = this.metadata.additionalInfo.targetHealthFactor;
 
     const k1 = token1Price.price * leg1LTV  / token2Price.price / TARGET_HF;
     const k2 = token1Price.price * TARGET_HF / token2Price.price / leg2LTV;
@@ -399,14 +554,12 @@ export class UniversalStrategy<
 
     if (params.isLeg1toLeg2) {
       const manageCall = this.getManageCall([
-        UNIVERSAL_MANAGE_IDS.VESU_LEG1,
-        UNIVERSAL_MANAGE_IDS.VESU_LEG2
+        ...callSet1.map(i => i.step), ...callSet2.map(i => i.step)
       ], [...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.step), ...callSet1.map(i => i.step)
       ], [...callSet2.map(i => i.manageCall), ...callSet1.map(i => i.manageCall)]);
       return manageCall;
     }
@@ -484,16 +637,22 @@ const usdcVaultSettings: UniversalStrategySettings = {
   manager: ContractAddr.from('0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07'),
   vaultAllocator: ContractAddr.from('0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba'),
   redeemRequestNFT: ContractAddr.from('0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda'),
+  aumOracle: ContractAddr.from("0x6faf45ed185dec13ef723c9ead4266cab98d06f2cb237e331b1fa5c2aa79afe"),
   leafAdapters: [],
-  adapters: []
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
 }
 
 const wbtcVaultSettings: UniversalStrategySettings = {
   manager: ContractAddr.from('0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34'),
   vaultAllocator: ContractAddr.from('0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735'),
   redeemRequestNFT: ContractAddr.from('0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2'),
+  aumOracle: ContractAddr.from("0x2edf4edbed3f839e7f07dcd913e92299898ff4cf0ba532f8c572c66c5b331b2"),
   leafAdapters: [],
-  adapters: []
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
 }
 
 export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[] =

package/src/utils/cacheClass.ts

@@ -0,0 +1,29 @@
+interface CacheData {
+  timestamp: number;
+  ttl: number;
+  data: any;
+}
+export class CacheClass {
+    readonly cache: Map<string, CacheData> = new Map();
+
+    setCache(key: string, data: any, ttl: number = 60000): void {
+        const timestamp = Date.now();
+        this.cache.set(key, { timestamp, ttl, data });
+    }
+
+    getCache<T>(key: string): T | null {
+        const cachedData = this.cache.get(key);
+        if (!cachedData || !this.isCacheValid(key)) {
+            return null;
+        }
+        return cachedData.data;
+    }
+
+    isCacheValid(key: string): boolean {
+        const cachedData = this.cache.get(key);
+        if (!cachedData) return false;
+
+        const { timestamp, ttl } = cachedData;
+        return Date.now() - timestamp <= ttl;
+    }
+}

package/src/utils/oz-merkle.ts

@@ -59,15 +59,6 @@ export class StandardMerkleTree extends MerkleTreeImpl<LeafData> {
     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);