feat: init commit

Author: rhlsthrm

chainDeploy/helpers/dynamicFlywheels.ts

@@ -0,0 +1,76 @@
+import { zeroAddress, Hash, Address } from "viem";
+
+import { FuseFlywheelDeployFnParams } from "..";
+
+export const deployFlywheelWithDynamicRewards = async ({
+  viem,
+  getNamedAccounts,
+  deployments,
+  deployConfig
+}: FuseFlywheelDeployFnParams): Promise<Array<string>> => {
+  const { deployer } = await getNamedAccounts();
+  const publicClient = await viem.getPublicClient();
+
+  const dynamicFlywheels = [];
+
+  for (const config of deployConfig.dynamicFlywheels!) {
+    if (config) {
+      console.log(`Deploying IonicFlywheel & ReplacingFlywheelDynamicRewards for ${config.rewardToken} reward token`);
+      const flywheelBooster = await viem.getContractAt(
+        "LooplessFlywheelBooster",
+        (await deployments.get("LooplessFlywheelBooster")).address as Address
+      );
+      const flywheelToReplace = config.flywheelToReplace ? config.flywheelToReplace : zeroAddress;
+
+      //// IonicFlywheelCore with Dynamic Rewards
+      const fwc = await deployments.deploy(`IonicFlywheel_${config.name}`, {
+        contract: "IonicFlywheel",
+        from: deployer,
+        log: true,
+        proxy: {
+          execute: {
+            init: {
+              methodName: "initialize",
+              args: [config.rewardToken, zeroAddress, flywheelBooster.address, deployer]
+            }
+          },
+          proxyContract: "OpenZeppelinTransparentProxy",
+          owner: deployer
+        },
+        waitConfirmations: 1
+      });
+      if (fwc.transactionHash) {
+        await publicClient.waitForTransactionReceipt({ hash: fwc.transactionHash as Hash });
+      }
+      console.log("IonicFlywheel: ", fwc.address);
+
+      const fdr = await deployments.deploy(`ReplacingFlywheelDynamicRewards_${config.name}`, {
+        contract: "ReplacingFlywheelDynamicRewards",
+        from: deployer,
+        args: [flywheelToReplace, fwc.address, config.cycleLength],
+        log: true,
+        waitConfirmations: 1
+      });
+      if (fdr.transactionHash) {
+        await publicClient.waitForTransactionReceipt({ hash: fdr.transactionHash as Hash });
+      }
+      console.log("ReplacingFlywheelDynamicRewards: ", fdr.address);
+
+      const flywheelCore = await viem.getContractAt(
+        `IonicFlywheel_${config.name}`,
+        (await deployments.get(`IonicFlywheel_${config.name}`)).address as Address
+      );
+      const currentRewards = await flywheelCore.read.flywheelRewards();
+      if (currentRewards != fdr.address) {
+        const hash = await flywheelCore.write.setFlywheelRewards([fdr.address]);
+        await publicClient.waitForTransactionReceipt({ hash });
+        console.log("setFlywheelRewards: ", hash);
+      } else {
+        console.log(`rewards contract already set`);
+      }
+
+      dynamicFlywheels.push(fwc.address);
+    }
+  }
+  return dynamicFlywheels;
+};

chainDeploy/helpers/getCgPrice.ts

@@ -0,0 +1,27 @@
+import axios from "axios";
+
+export const getCgPrice = async (coingeckoId: string) => {
+  let usdPrice = NaN;
+
+  try {
+    const { data } = await axios.get(
+      `https://api.coingecko.com/api/v3/simple/price?vs_currencies=usd&ids=${coingeckoId}`
+    );
+
+    if (data[coingeckoId] && data[coingeckoId].usd) {
+      usdPrice = data[coingeckoId].usd;
+    }
+  } catch (e) {
+    const { data } = await axios.get(`https://coins.llama.fi/prices/current/coingecko:${coingeckoId}`);
+
+    if (data.coins[`coingecko:${coingeckoId}`] && data.coins[`coingecko:${coingeckoId}`].price) {
+      usdPrice = data.coins[`coingecko:${coingeckoId}`].price;
+    }
+  }
+
+  if (usdPrice) {
+    return usdPrice;
+  } else {
+    return 1;
+  }
+};

chainDeploy/helpers/index.ts

@@ -0,0 +1,6 @@
+export { ChainDeployConfig, ChainlinkFeedBaseCurrency } from "../../chains/types";
+export { deployIRMs } from "./irms";
+export { deployChainlinkOracle } from "./oracles/chainlink";
+export { deployFlywheelWithDynamicRewards } from "./dynamicFlywheels";
+export { deployErc4626PriceOracle } from "./oracles/erc4626";
+export { configureBalancerSwap } from "./liquidators/ionicLiquidator";

chainDeploy/helpers/irms.ts

@@ -0,0 +1,26 @@
+import { parseEther } from "viem";
+import { IrmDeployFnParams } from "../../chains/types";
+
+export const deployIRMs = async ({
+  viem,
+  getNamedAccounts,
+  deployments,
+  deployConfig
+}: IrmDeployFnParams): Promise<void> => {
+  const publicClient = await viem.getPublicClient();
+  const { deployer } = await getNamedAccounts();
+  //// IRM MODELS|
+  const jrm = await deployments.deploy("JumpRateModel", {
+    from: deployer,
+    args: [
+      deployConfig.blocksPerYear,
+      parseEther("0").toString(), // baseRatePerYear   0
+      parseEther("0.18").toString(), // multiplierPerYear 0.18
+      parseEther("4").toString(), //jumpMultiplierPerYear 4
+      parseEther("0.8").toString() // kink               0.8
+    ],
+    log: true
+  });
+  if (jrm.transactionHash) await publicClient.waitForTransactionReceipt({ hash: jrm.transactionHash });
+  console.log("JumpRateModel: ", jrm.address);
+};