@strkfarm/sdk 1.0.57 → 1.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "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",
@@ -54,11 +54,12 @@
     "@types/react": "^19.1.2",
     "axios": "^1.7.2",
     "react": "19.1.0",
-    "starknet": "^6.11.0"
+    "starknet": "7.6.4"
   },
   "dependencies": {
     "@avnu/avnu-sdk": "3.0.2",
     "@ericnordelo/strk-merkle-tree": "^1.0.0",
+    "@scure/starknet": "^2.0.0",
     "bignumber.js": "4.0.4",
     "browser-assert": "^1.2.1",
     "chalk": "^4.1.2",

package/src/interfaces/common.tsx

@@ -1,5 +1,5 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { BlockIdentifier, RpcProvider } from "starknet";
+import { BlockIdentifier, constants, RpcProvider } from "starknet";
 import React, { ReactNode } from "react";
 
 export enum RiskType {
@@ -107,12 +107,14 @@ export interface IInvestmentFlow {
 
 export function getMainnetConfig(
   rpcUrl: string = 'https://starknet-mainnet.public.blastapi.io',
-  blockIdentifier: BlockIdentifier = "pending"
+  blockIdentifier: BlockIdentifier = "pending",
+  // specVersion = constants.SupportedRpcVersion.v0_8_1
 ): IConfig {
   return {
     provider: new RpcProvider({
       nodeUrl: rpcUrl,
-      blockIdentifier: blockIdentifier
+      blockIdentifier: blockIdentifier,
+      // specVersion
     }),
     stage: "production",
     network: Network.mainnet

package/src/node/deployer.ts

@@ -36,7 +36,7 @@ function getAccount(
         PASSWORD: password
     });
     
-    return store.getAccount(accountKey);
+    return store.getAccount(accountKey, '0x3');
 }
 
 async function myDeclare(contract_name: string, package_name: string = 'strkfarm', config: IConfig, acc: Account) {
@@ -96,7 +96,7 @@ async function deployContract(contract_name: string, classHash: string, construc
         classHash,
         constructorCalldata: constructorData,
     })
-    console.log("Deploy fee", contract_name, Number(fee.suggestedMaxFee) / 10 ** 18, 'ETH')
+    console.log("Deploy fee", contract_name, Number(fee.overall_fee) / 10 ** 18, 'ETH')
 
     const tx = await acc.deployContract({
         classHash,

package/src/strategies/universal-strategy.ts

@@ -9,17 +9,23 @@ 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}[],
   targetHealthFactor: number,
   minHealthFactor: number
 }
 
+export enum AUMTypes {
+  FINALISED = 'finalised',
+  DEFISPRING = 'defispring'
+}
 
 export class UniversalStrategy<
   S extends UniversalStrategySettings
@@ -139,6 +145,20 @@ export class UniversalStrategy<
     return [call1, call2];
   }
 
+  async withdrawCall(amountInfo: SingleActionAmount, receiver: ContractAddr, owner: ContractAddr): Promise<Call[]> {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = await this.contract.call('convert_to_shares', [uint256.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint256.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
+
   /**
    * Calculates the Total Value Locked (TVL) for a specific user.
    * @param user - Address of the user
@@ -190,14 +210,22 @@ export class UniversalStrategy<
     const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
 
     const positions = await this.getVaultPositions();
+    logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    if (positions.every(p => p.amount.isZero())) {
+      return { net: 0, splits: [{
+        apy: 0, id: 'base'
+      }, {
+        apy: 0, id: 'defispring'
+      }]};
+    }
     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;
+    logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
     return { net: netAPY, splits: [{
       apy: baseAPY, id: 'base'
     }, {
@@ -233,6 +261,17 @@ export class UniversalStrategy<
     };
   }
 
+  async getUnusedBalance(): Promise<SingleTokenInfo> {
+    const balance = await (new ERC20(this.config)).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
+
   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', []);
@@ -244,10 +283,29 @@ export class UniversalStrategy<
     const leg1AUM = await vesuAdapter1.getPositions(this.config);
     const leg2AUM = await vesuAdapter2.getPositions(this.config);
 
-    const aumToken = leg1AUM[0].amount
+    const balance = await this.getUnusedBalance();
+    logger.verbose(`${this.getTag()} unused balance: ${balance.amount.toNumber()}`);
+
+    const vesuAum = leg1AUM[0].amount
       .plus(leg2AUM[0].usdValue / token1Price.price)
       .minus(leg1AUM[1].usdValue / token1Price.price)
       .minus(leg2AUM[1].amount);
+
+    const zeroAmt = Web3Number.fromWei('0', this.asset().decimals);
+    const net = {
+      tokenInfo: this.asset(),
+      amount: zeroAmt,
+      usdValue: 0
+    };
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    if (vesuAum.isZero()) {
+      return { net, splits: [{
+        aum: zeroAmt, id: AUMTypes.FINALISED
+      }, {
+        aum: zeroAmt, id: AUMTypes.DEFISPRING
+      }], prevAum};
+    }
+    const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
 
     // calculate estimated growth from strk rewards
@@ -257,7 +315,6 @@ export class UniversalStrategy<
 
     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}`);
@@ -267,16 +324,13 @@ export class UniversalStrategy<
     const newAUM = aumToken.plus(rewardAssets);
     logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
     
-    const net = {
-      tokenInfo: this.asset(),
-      amount: newAUM,
-      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
-    };
+    net.amount = newAUM;
+    net.usdValue = newAUM.multipliedBy(token1Price.price).toNumber();
     const splits = [{
-      id: 'finalised',
+      id: AUMTypes.FINALISED,
       aum: aumToken
     }, {
-      id: 'defispring',
+      id: AUMTypes.DEFISPRING,
       aum: rewardAssets
     }];
     return { net, splits, prevAum };
@@ -632,6 +686,7 @@ const usdcVaultSettings: UniversalStrategySettings = {
   manager: ContractAddr.from('0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07'),
   vaultAllocator: ContractAddr.from('0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba'),
   redeemRequestNFT: ContractAddr.from('0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda'),
+  aumOracle: ContractAddr.from("0x6faf45ed185dec13ef723c9ead4266cab98d06f2cb237e331b1fa5c2aa79afe"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.3,
@@ -642,6 +697,40 @@ const wbtcVaultSettings: UniversalStrategySettings = {
   manager: ContractAddr.from('0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34'),
   vaultAllocator: ContractAddr.from('0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735'),
   redeemRequestNFT: ContractAddr.from('0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2'),
+  aumOracle: ContractAddr.from("0x2edf4edbed3f839e7f07dcd913e92299898ff4cf0ba532f8c572c66c5b331b2"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const ethVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0x494888b37206616bd09d759dcda61e5118470b9aa7f58fb84f21c778a7b8f97'),
+  vaultAllocator: ContractAddr.from('0x4acc0ad6bea58cb578d60ff7c31f06f44369a7a9a7bbfffe4701f143e427bd'),
+  redeemRequestNFT: ContractAddr.from('0x2e6cd71e5060a254d4db00655e420db7bf89da7755bb0d5f922e2f00c76ac49'),
+  aumOracle: ContractAddr.from("0x4b747f2e75c057bed9aa2ce46fbdc2159dc684c15bd32d4f95983a6ecf39a05"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const strkVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0xcc6a5153ca56293405506eb20826a379d982cd738008ef7e808454d318fb81'),
+  vaultAllocator: ContractAddr.from('0xf29d2f82e896c0ed74c9eff220af34ac148e8b99846d1ace9fbb02c9191d01'),
+  redeemRequestNFT: ContractAddr.from('0x46902423bd632c428376b84fcee9cac5dbe016214e93a8103bcbde6e1de656b'),
+  aumOracle: ContractAddr.from("0x6d7dbfad4bb51715da211468389a623da00c0625f8f6efbea822ee5ac5231f4"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+}
+
+const usdtVaultSettings: UniversalStrategySettings = {
+  manager: ContractAddr.from('0x39bb9843503799b552b7ed84b31c06e4ff10c0537edcddfbf01fe944b864029'),
+  vaultAllocator: ContractAddr.from('0x56437d18c43727ac971f6c7086031cad7d9d6ccb340f4f3785a74cc791c931a'),
+  redeemRequestNFT: ContractAddr.from('0x5af0c2a657eaa8e23ed78e855dac0c51e4f69e2cf91a18c472041a1f75bb41f'),
+  aumOracle: ContractAddr.from("0x7018f8040c8066a4ab929e6760ae52dd43b6a3a289172f514750a61fcc565cc"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.3,
@@ -692,4 +781,67 @@ export const UniversalStrategies: IStrategyMetadata<UniversalStrategySettings>[]
       faqs: [],
       investmentSteps: [],
     },
+    {
+      name: "ETH Evergreen",
+      description: "A universal strategy for managing ETH assets",
+      address: ContractAddr.from('0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'ETH')!],
+      additionalInfo: getLooperSettings('ETH', 'WBTC', ethVaultSettings, 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, 18),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+    {
+      name: "STRK Evergreen",
+      description: "A universal strategy for managing STRK assets",
+      address: ContractAddr.from('0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'STRK')!],
+      additionalInfo: getLooperSettings('STRK', 'ETH', strkVaultSettings, 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, 18),
+      contractDetails: [],
+      faqs: [],
+      investmentSteps: [],
+    },
+    {
+      name: "USDT Evergreen",
+      description: "A universal strategy for managing USDT assets",
+      address: ContractAddr.from('0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3'),
+      launchBlock: 0,
+      type: 'ERC4626',
+      depositTokens: [Global.getDefaultTokens().find(token => token.symbol === 'USDT')!],
+      additionalInfo: getLooperSettings('USDT', 'ETH', usdtVaultSettings, 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: [],
+    }
   ]

package/src/utils/cacheClass.ts

@@ -1,29 +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;
-    }
+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;
+    }
 }