CApe Migration

contracts/misc/HelperContract.sol

@@ -13,17 +13,20 @@ contract HelperContract is Initializable, OwnableUpgradeable {
     using SafeERC20 for IERC20;
 
     address internal immutable apeCoin;
+    address internal immutable cApeV1;
     address internal immutable cApe;
     address internal immutable pcApe;
     address internal immutable lendingPool;
 
     constructor(
         address _apeCoin,
+        address _cApeV1,
         address _cApe,
         address _pcApe,
         address _lendingPool
     ) {
         apeCoin = _apeCoin;
+        cApeV1 = _cApeV1;
         cApe = _cApe;
         pcApe = _pcApe;
         lendingPool = _lendingPool;
@@ -57,4 +60,10 @@ contract HelperContract is Initializable, OwnableUpgradeable {
         IAutoCompoundApe(cApe).withdraw(amount);
         IERC20(apeCoin).safeTransfer(msg.sender, amount);
     }
+
+    function cApeMigration(uint256 amount) external {
+        IERC20(cApeV1).safeTransferFrom(msg.sender, address(this), amount);
+        IAutoCompoundApe(cApeV1).withdraw(amount);
+        IAutoCompoundApe(cApe).deposit(msg.sender, amount);
+    }
 }

helpers/contracts-deployments.ts

@@ -2840,7 +2840,7 @@ export const deployAutoYieldApeImplAndAssignItToProxy = async (
   );
 };
 
-export const deployHelperContractImpl = async (verify?: boolean) => {
+export const deployHelperContractImpl = async (cApeV1: tEthereumAddress, verify?: boolean) => {
   const allTokens = await getAllTokens();
   const protocolDataProvider = await getProtocolDataProvider();
   const pCApe = (
@@ -2849,6 +2849,7 @@ export const deployHelperContractImpl = async (verify?: boolean) => {
   const pool = await getPoolProxy();
   const args = [
     allTokens.APE.address,
+    cApeV1,
     allTokens.cAPE.address,
     pCApe,
     pool.address,
@@ -2862,8 +2863,8 @@ export const deployHelperContractImpl = async (verify?: boolean) => {
   ) as Promise<HelperContract>;
 };
 
-export const deployHelperContract = async (verify?: boolean) => {
-  const helperImplementation = await deployHelperContractImpl(verify);
+export const deployHelperContract = async (cApeV1: tEthereumAddress, verify?: boolean) => {
+  const helperImplementation = await deployHelperContractImpl(cApeV1, verify);
 
   const deployer = await getFirstSigner();
   const deployerAddress = await deployer.getAddress();

scripts/deployments/steps/21_helperContract.ts

@@ -1,14 +1,17 @@
 import {deployHelperContract} from "../../../helpers/contracts-deployments";
 import {getParaSpaceConfig} from "../../../helpers/misc-utils";
 import {ERC20TokenContractId} from "../../../helpers/types";
+import {getAllTokens} from "../../../helpers/contracts-getters";
 export const step_21 = async (verify = false) => {
   const paraSpaceConfig = getParaSpaceConfig();
   try {
     if (!paraSpaceConfig.ReservesConfig[ERC20TokenContractId.APE]) {
       return;
     }
 
-    await deployHelperContract(verify);
+    const allTokens = await getAllTokens();
+    //for test env, we use same address for cApeV1 and cApeV2
+    await deployHelperContract(allTokens.cAPE.address, verify);
   } catch (error) {
     console.error(error);
     process.exit(1);

test/helper_contract.spec.ts

@@ -12,6 +12,8 @@ import {MAX_UINT_AMOUNT} from "../helpers/constants";
 import {parseEther} from "ethers/lib/utils";
 import {almostEqual} from "./helpers/uniswapv3-helper";
 import {waitForTx} from "../helpers/misc-utils";
+import {deployAutoCompoundApeImplAndAssignItToProxy} from "../helpers/contracts-deployments";
+import {expect} from "chai";
 
 describe("Helper contract Test", () => {
   let testEnv: TestEnv;
@@ -90,4 +92,35 @@ describe("Helper contract Test", () => {
     const apeBalance = await ape.balanceOf(user1.address);
     almostEqual(apeBalance, parseEther("10000"));
   });
+
+  it("cApeMigration", async () => {
+    const {
+      users: [user1],
+      ape,
+    } = await loadFixture(fixture);
+
+    await mintAndValidate(ape, "10000", user1);
+    await waitForTx(
+        await ape
+            .connect(user1.signer)
+            .approve(cApe.address, MAX_UINT_AMOUNT)
+    );
+
+    await waitForTx(
+        await cApe.connect(user1.signer).deposit(user1.address, parseEther("10000"))
+    );
+    expect(await cApe.balanceOf(user1.address)).to.be.eq(parseEther("10000"))
+
+    await waitForTx(
+        await cApe
+            .connect(user1.signer)
+            .approve(helperContract.address, MAX_UINT_AMOUNT)
+    );
+    await waitForTx(
+        await helperContract
+            .connect(user1.signer)
+            .cApeMigration(parseEther("10000"))
+    );
+    expect(await cApe.balanceOf(user1.address)).to.be.eq(parseEther("10000"))
+  });
 });