Add stablecoin pool (#49)

* Add stablecoin pool

* Fix lint

* Add test for borrow and repay with swap

* Add stablecoin pool to deploy script

* Cleanup deploy script and solidity warnings

* Add standalone deploy stablecoin pool script

Cleanup

---------

Co-authored-by: Oleksii Matiiasevych <[email protected]>

Author: viatrix

contracts/LiquidityPoolStablecoin.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {LiquidityPool} from "./LiquidityPool.sol";
+
+/// @title A version of the liquidity pool contract that supports multiple assets for borrowing.
+/// It's possible to borrow any tokens that are present in the pool.
+/// @author Tanya Bushenyova <[email protected]>
+contract LiquidityPoolStablecoin is LiquidityPool {
+    using SafeERC20 for IERC20;
+
+    error WithdrawProfitDenied();
+
+    constructor(
+        address liquidityToken,
+        address admin,
+        address mpcAddress_
+    ) LiquidityPool(liquidityToken, admin, mpcAddress_) {
+        return;
+    }
+
+    function _borrowLogic(address /*borrowToken*/, uint256 /*amount*/, address /*target*/) internal pure override {
+        return;
+    }
+
+    function _withdrawProfitLogic(IERC20 token) internal view override returns (uint256) {
+        uint256 assetBalance = ASSETS.balanceOf(address(this));
+        uint256 deposited = totalDeposited;
+        require(assetBalance >= deposited, WithdrawProfitDenied());
+        if (token == ASSETS) return assetBalance - deposited;
+        return token.balanceOf(address(this));
+    }
+}

network.config.ts

@@ -2,6 +2,7 @@ import * as AAVEPools from "@bgd-labs/aave-address-book";
 
 export const LiquidityPoolAaveUSDC: string = "LiquidityPoolAaveUSDC";
 export const LiquidityPoolUSDC: string = "LiquidityPoolUSDC";
+export const LiquidityPoolUSDCStablecoin: string = "LiquidityPoolUSDCStablecoin";
 
 export enum Network {
   ETHEREUM = "ETHEREUM",
@@ -86,6 +87,7 @@ export interface NetworkConfig {
   Hub?: HubConfig;
   AavePool?: AavePoolConfig;
   USDCPool?: boolean;
+  USDCStablecoinPool?: boolean;
   Stage?: NetworkConfig;
 };
 

package.json

@@ -22,9 +22,7 @@
     "redeploy-stash-base": "hardhat run ./scripts/redeployStash.ts --network BASE",
     "deploy-censoredmulticall-ethereum": "hardhat run ./scripts/deployCensoredMulticall.ts --network ETHEREUM",
     "deploy-usdcpool-base-stage": "DEPLOY_TYPE=STAGE hardhat run ./scripts/deployUSDCPool.ts --network BASE",
-    "upgrade-liquiditypool": "hardhat run ./scripts/upgradeLiquidityPool.ts",
-    "upgrade-liquiditypool-basesepolia": "hardhat run ./scripts/upgradeLiquidityPool.ts --network BASE_SEPOLIA",
-    "upgrade-liquiditypool-ethereumsepolia": "hardhat run ./scripts/upgradeLiquidityPool.ts --network ETHEREUM_SEPOLIA",
+    "deploy-usdcstablecoinpool-base-stage": "DEPLOY_TYPE=STAGE hardhat run ./scripts/deployUSDCStablecoinPool.ts --network BASE",
     "deploy-repayer-base": "hardhat run ./scripts/deployRepayer.ts --network BASE",
     "deploy-repayer-arbitrumone": "hardhat run ./scripts/deployRepayer.ts --network ARBITRUM_ONE",
     "deploy-repayer-opmainnet": "hardhat run ./scripts/deployRepayer.ts --network OP_MAINNET",
@@ -50,6 +48,7 @@
     "dry:redeploy-stash-base": "DRY_RUN=BASE VERIFY=false ts-node --files ./scripts/redeployStash.ts",
     "dry:deploy-censoredmulticall-ethereum": "DRY_RUN=ETHEREUM VERIFY=false ts-node --files ./scripts/deployCensoredMulticall.ts",
     "dry:deploy-usdcpool-base-stage": "DRY_RUN=BASE DEPLOY_TYPE=STAGE VERIFY=false ts-node --files ./scripts/deployUSDCPool.ts",
+    "dry:deploy-usdcstablecoinpool-base-stage": "DRY_RUN=BASE DEPLOY_TYPE=STAGE VERIFY=false ts-node --files ./scripts/deployUSDCStablecoinPool.ts",
     "dry:deploy-repayer-base": "DRY_RUN=BASE VERIFY=false ts-node --files ./scripts/deployRepayer.ts",
     "dry:deploy-repayer-arbitrumone": "DRY_RUN=ARBITRUM_ONE VERIFY=false ts-node --files ./scripts/deployRepayer.ts",
     "dry:deploy-repayer-opmainnet": "DRY_RUN=OP_MAINNET VERIFY=false ts-node --files ./scripts/deployRepayer.ts",

scripts/deploy.ts

@@ -12,11 +12,11 @@ import {
 import {
   TestUSDC, SprinterUSDCLPShare, LiquidityHub,
   SprinterLiquidityMining, TestCCTPTokenMessenger, TestCCTPMessageTransmitter,
-  Rebalancer, Repayer, LiquidityPool, LiquidityPoolAave,
+  Rebalancer, Repayer, LiquidityPool, LiquidityPoolAave, LiquidityPoolStablecoin
 } from "../typechain-types";
 import {
   networkConfig, Network, Provider, NetworkConfig, LiquidityPoolUSDC,
-  LiquidityPoolAaveUSDC,
+  LiquidityPoolAaveUSDC, LiquidityPoolUSDCStablecoin
 } from "../network.config";
 
 export async function main() {
@@ -95,18 +95,21 @@ export async function main() {
         Providers: [Provider.CCTP],
         SupportsAllTokens: [false],
       },
-      USDCPool: true
+      USDCPool: true,
+      USDCStablecoinPool: true,
     };
   }
 
-  assert(config.AavePool !== undefined || config.USDCPool!, "At least one pool should be present.");
+  assert(config.AavePool! || config.USDCPool! || config.USDCStablecoinPool!,
+    "At least one pool should be present.");
   assert(isAddress(config.USDC), "USDC must be an address");
   assert(isAddress(config.Admin), "Admin must be an address");
   assert(isAddress(config.WithdrawProfit), "WithdrawProfit must be an address");
   assert(isAddress(config.Pauser), "Pauser must be an address");
   assert(isAddress(config.RebalanceCaller), "RebalanceCaller must be an address");
   assert(isAddress(config.RepayerCaller), "RepayerCaller must be an address");
   assert(isAddress(config.MpcAddress), "MpcAddress must be an address");
+
   if (config.Hub) {
     assert(config.Hub!.Tiers.length > 0, "Empty liquidity mining tiers configuration.");
     assert(config.Hub!.AssetsLimit <= MaxUint256 / 10n ** 12n, "Assets limit is too high");
@@ -189,6 +192,28 @@ export async function main() {
     }
   }
 
+  let usdcStablecoinPool: LiquidityPoolStablecoin;
+  if (config.USDCStablecoinPool) {
+    console.log("Deploying USDC Stablecoin Liquidity Pool");
+    usdcStablecoinPool = (await verifier.deployX(
+      "LiquidityPoolStablecoin", deployer, {}, [config.USDC, deployer, config.MpcAddress], LiquidityPoolUSDCStablecoin
+    )) as LiquidityPool;
+    console.log(`LiquidityPoolUSDCStablecoin: ${usdcStablecoinPool.target}`);
+
+    config.RebalancerRoutes.Pools.push(await usdcStablecoinPool.getAddress());
+    config.RebalancerRoutes.Domains.push(network);
+    config.RebalancerRoutes.Providers.push(Provider.LOCAL);
+
+    config.RepayerRoutes.Pools.push(await usdcStablecoinPool.getAddress());
+    config.RepayerRoutes.Domains.push(network);
+    config.RepayerRoutes.Providers.push(Provider.LOCAL);
+    config.RepayerRoutes.SupportsAllTokens.push(false);
+
+    if ((!config.AavePool) && (!config.USDCPool)) {
+      mainPool = usdcStablecoinPool;
+    }
+  }
+
   const rebalancerVersion = config.IsTest ? "TestRebalancer" : "Rebalancer";
 
   config.RebalancerRoutes.Pools = await verifier.predictDeployXAddresses(config.RebalancerRoutes!.Pools!, deployer);
@@ -221,6 +246,12 @@ export async function main() {
     await usdcPool!.grantRole(PAUSER_ROLE, config.Pauser);
   }
 
+  if (config.USDCStablecoinPool) {
+    await usdcStablecoinPool!.grantRole(LIQUIDITY_ADMIN_ROLE, rebalancer);
+    await usdcStablecoinPool!.grantRole(WITHDRAW_PROFIT_ROLE, config.WithdrawProfit);
+    await usdcStablecoinPool!.grantRole(PAUSER_ROLE, config.Pauser);
+  }
+
   const repayerVersion = config.IsTest ? "TestRepayer" : "Repayer";
 
   config.RepayerRoutes.Pools = await verifier.predictDeployXAddresses(config.RepayerRoutes!.Pools!, deployer);
@@ -304,6 +335,11 @@ export async function main() {
       await usdcPool!.grantRole(DEFAULT_ADMIN_ROLE, config.Admin);
       await usdcPool!.renounceRole(DEFAULT_ADMIN_ROLE, deployer);
     }
+
+    if (config.USDCStablecoinPool) {
+      await usdcStablecoinPool!.grantRole(DEFAULT_ADMIN_ROLE, config.Admin);
+      await usdcStablecoinPool!.renounceRole(DEFAULT_ADMIN_ROLE, deployer);
+    }
   }
 
   let multicall: string;

scripts/deployUSDCPool.ts

@@ -61,8 +61,10 @@ export async function main() {
   await usdcPool!.grantRole(WITHDRAW_PROFIT_ROLE, config.WithdrawProfit);
   await usdcPool!.grantRole(PAUSER_ROLE, config.Pauser);
 
-  await usdcPool!.grantRole(DEFAULT_ADMIN_ROLE, config.Admin);
-  await usdcPool!.renounceRole(DEFAULT_ADMIN_ROLE, deployer);
+  if (deployer.address !== config.Admin) {
+    await usdcPool!.grantRole(DEFAULT_ADMIN_ROLE, config.Admin);
+    await usdcPool!.renounceRole(DEFAULT_ADMIN_ROLE, deployer);
+  }
 
   await verifier.verify(process.env.VERIFY === "true");
 }

scripts/deployUSDCStablecoinPool.ts

@@ -0,0 +1,74 @@
+import dotenv from "dotenv"; 
+dotenv.config();
+import hre from "hardhat";
+import {getVerifier} from "./helpers";
+import {resolveProxyXAddress, toBytes32} from "../test/helpers";
+import {isSet, assert, DEFAULT_ADMIN_ROLE} from "./common";
+import {LiquidityPoolStablecoin} from "../typechain-types";
+import {networkConfig, Network, NetworkConfig, LiquidityPoolUSDCStablecoin} from "../network.config";
+
+export async function main() {
+  const [deployer] = await hre.ethers.getSigners();
+
+  const LIQUIDITY_ADMIN_ROLE = toBytes32("LIQUIDITY_ADMIN_ROLE");
+  const WITHDRAW_PROFIT_ROLE = toBytes32("WITHDRAW_PROFIT_ROLE");
+  const PAUSER_ROLE = toBytes32("PAUSER_ROLE");
+
+  assert(isSet(process.env.DEPLOY_ID), "DEPLOY_ID must be set");
+  const verifier = getVerifier(process.env.DEPLOY_ID);
+  console.log(`Deployment ID: ${process.env.DEPLOY_ID}`);
+
+  let network: Network;
+  let config: NetworkConfig;
+  console.log(`Deploying to: ${hre.network.name}`);
+  if (hre.network.name === "hardhat" && Object.values(Network).includes(process.env.DRY_RUN as Network)) {
+    network = process.env.DRY_RUN as Network;
+    config = networkConfig[network];
+    if (process.env.DEPLOY_TYPE == "STAGE") {
+      assert(config.Stage != undefined, "Stage config must be defined");
+      console.log(`Dry run for deploying staging USDC stablecoin pool on fork: ${network}`);
+      config = config.Stage!;
+    } else {
+      console.log(`Dry run for deploying USDC stablecoin pool on fork: ${network}`);
+    }
+  } else if (Object.values(Network).includes(hre.network.name as Network)) {
+    network = hre.network.name as Network;
+    config = networkConfig[network];
+    if (process.env.DEPLOY_TYPE == "STAGE") {
+      assert(config.Stage != undefined, "Stage config must be defined");
+      console.log(`Deploying staging USDC stablecoin pool on: ${network}`);
+      config = config.Stage!;
+    } else {
+      console.log(`Deploying USDC stablecoin pool on: ${network}`);
+    }
+  } else {
+    console.log(`Nothing to deploy on ${hre.network.name} network`);
+    return;
+  }
+
+  assert(config.USDCStablecoinPool, "USDC stablecoin pool is not configured");
+
+  const rebalancer = await resolveProxyXAddress("Rebalancer");
+  console.log(`Rebalancer: ${rebalancer}`);
+
+  console.log("Deploying USDC Stablecoin Liquidity Pool");
+  const usdcPoolStablecoin: LiquidityPoolStablecoin = (await verifier.deployX(
+    "LiquidityPoolStablecoin", deployer, {}, [config.USDC, deployer, config.MpcAddress], LiquidityPoolUSDCStablecoin
+  )) as LiquidityPoolStablecoin;
+  console.log(`LiquidityPoolUSDCStablecoin: ${usdcPoolStablecoin.target}`);
+
+  await usdcPoolStablecoin!.grantRole(LIQUIDITY_ADMIN_ROLE, rebalancer);
+  await usdcPoolStablecoin!.grantRole(WITHDRAW_PROFIT_ROLE, config.WithdrawProfit);
+  await usdcPoolStablecoin!.grantRole(PAUSER_ROLE, config.Pauser);
+
+  if (deployer.address !== config.Admin) {
+    await usdcPoolStablecoin!.grantRole(DEFAULT_ADMIN_ROLE, config.Admin);
+    await usdcPoolStablecoin!.renounceRole(DEFAULT_ADMIN_ROLE, deployer);
+  }
+
+  await verifier.verify(process.env.VERIFY === "true");
+}
+
+if (process.env.SCRIPT_ENV !== "CI") {
+  main();
+}

scripts/test.ts

@@ -6,6 +6,7 @@ import {main as upgradeRebalancer} from "./upgradeRebalancer";
 import {main as redeployStash} from "./redeployStash";
 import {main as deployCensoredMulticall} from "./deployCensoredMulticall";
 import {main as deployUSDCPool} from "./deployUSDCPool";
+import {main as deployUSDCStablecoinPool} from "./deployUSDCStablecoinPool";
 import {main as deployRepayer} from "./deployRepayer";
 import {main as upgradeLiquidityHub} from "./upgradeLiquidityHub";
 
@@ -21,6 +22,8 @@ async function main() {
   await deployCensoredMulticall();
   console.log("Test deployUSDCPool.")
   await deployUSDCPool();
+  console.log("Test deployUSDCStablecoinPool.")
+  await deployUSDCStablecoinPool();
   console.log("Test deployRepayer.")
   await deployRepayer();
   console.log("Test upgradeLiquidityHub.")

test/LiquidityPoolAave.ts

@@ -866,7 +866,7 @@ describe("LiquidityPoolAave", function () {
       await expect(liquidityPool.connect(liquidityAdmin).deposit(amountCollateral))
         .to.emit(liquidityPool, "SuppliedToAave");
 
-      const amountToBorrow = 10n * UNI_DEC;
+      const amountToBorrow = 20n * UNI_DEC;
 
       const signature = await signBorrow(
         mpc_signer,