Implement Curve Pool Booster.

contracts/contracts/interfaces/ICampaignRemoteManager.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ICampaingRemoteManager {
+    function createCampaign(
+        CampaignCreationParams memory params,
+        uint256 destinationChainId,
+        uint256 additionalGasLimit
+    ) external payable;
+
+    function manageCampaign(
+        CampaignManagementParams memory params,
+        uint256 destinationChainId,
+        uint256 additionalGasLimit
+    ) external payable;
+
+    struct CampaignCreationParams {
+        uint256 chainId;
+        address gauge;
+        address manager;
+        address rewardToken;
+        uint8 numberOfPeriods;
+        uint256 maxRewardPerVote;
+        uint256 totalRewardAmount;
+        address[] addresses;
+        address hook;
+        bool isWhitelist;
+    }
+
+    struct CampaignManagementParams {
+        uint256 campaignId;
+        address rewardToken;
+        uint8 numberOfPeriods;
+        uint256 totalRewardAmount;
+        uint256 maxRewardPerVote;
+    }
+}

contracts/contracts/proxies/Proxies.sol

@@ -358,3 +358,10 @@ contract MorphoGauntletPrimeUSDTStrategyProxy is
 {
 
 }
+
+/**
+ * @notice CurvePoolBoosterProxy delegates calls to a CurvePoolBooster implementation
+ */
+contract CurvePoolBoosterProxy is InitializeGovernedUpgradeabilityProxy {
+
+}

contracts/contracts/strategies/CurvePoolBooster.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { Governable } from "../governance/Governable.sol";
+import { Initializable } from "../utils/Initializable.sol";
+import { ICampaingRemoteManager } from "../interfaces/ICampaignRemoteManager.sol";
+
+contract CurvePoolBooster is Initializable, Governable {
+    address public immutable gauge;
+    address public immutable rewardToken;
+    address public immutable campaignRemoteManager;
+    uint256 public immutable targetChainId;
+
+    address public operator;
+    uint256 public campaignId;
+
+    modifier onlyOperator() {
+        require(
+            msg.sender == operator || isGovernor(),
+            "Only Operator or Governor"
+        );
+        _;
+    }
+
+    constructor(
+        uint256 _targetChainId,
+        address _campaignRemoteManager,
+        address _rewardToken,
+        address _gauge
+    ) {
+        targetChainId = _targetChainId;
+        campaignRemoteManager = _campaignRemoteManager;
+        rewardToken = _rewardToken;
+        gauge = _gauge;
+
+        // Prevent implementation contract to be governed
+        _setGovernor(address(0));
+    }
+
+    function initialize(address _operator) external initializer {
+        operator = _operator;
+    }
+
+    function createCampaign(
+        uint8 numberOfPeriods,
+        uint256 maxRewardPerVote,
+        uint256 bridgeFee,
+        uint256 additionalGasLimit
+    ) external onlyOperator {
+        require(campaignId == 0, "Campaign already created");
+
+        // Cache current rewardToken balance
+        uint256 totalRewardAmount = IERC20(rewardToken).balanceOf(
+            address(this)
+        );
+
+        // Approve the total reward amount to the campaign manager
+        IERC20(rewardToken).approve(campaignRemoteManager, totalRewardAmount);
+
+        // Create a new campaign
+        ICampaingRemoteManager(campaignRemoteManager).createCampaign{
+            value: bridgeFee
+        }(
+            ICampaingRemoteManager.CampaignCreationParams({
+                chainId: targetChainId,
+                gauge: gauge,
+                manager: address(this),
+                rewardToken: rewardToken,
+                numberOfPeriods: numberOfPeriods,
+                maxRewardPerVote: maxRewardPerVote,
+                totalRewardAmount: totalRewardAmount,
+                addresses: new address[](0),
+                hook: address(0),
+                isWhitelist: false
+            }),
+            targetChainId,
+            additionalGasLimit
+        );
+    }
+
+    function manageTotalRewardAmount(
+        uint256 bridgeFee,
+        uint256 additionalGasLimit
+    ) external onlyOperator {
+        require(campaignId != 0, "Campaign not created");
+
+        // Cache current rewardToken balance
+        uint256 extraTotalRewardAmount = IERC20(rewardToken).balanceOf(
+            address(this)
+        );
+
+        // Approve the total reward amount to the campaign manager
+        require(extraTotalRewardAmount > 0, "No reward to manage");
+
+        // Approve the total reward amount to the campaign manager
+        IERC20(rewardToken).approve(
+            campaignRemoteManager,
+            extraTotalRewardAmount
+        );
+
+        // Manage the campaign
+        ICampaingRemoteManager(campaignRemoteManager).manageCampaign{
+            value: bridgeFee
+        }(
+            ICampaingRemoteManager.CampaignManagementParams({
+                campaignId: campaignId,
+                rewardToken: rewardToken,
+                numberOfPeriods: 0,
+                totalRewardAmount: extraTotalRewardAmount,
+                maxRewardPerVote: 0
+            }),
+            targetChainId,
+            additionalGasLimit
+        );
+    }
+
+    function manageNumberOfPeriods(
+        uint8 extraNumberOfPeriods,
+        uint256 bridgeFee,
+        uint256 additionalGasLimit
+    ) external onlyOperator {
+        require(campaignId != 0, "Campaign not created");
+
+        ICampaingRemoteManager(campaignRemoteManager).manageCampaign{
+            value: bridgeFee
+        }(
+            ICampaingRemoteManager.CampaignManagementParams({
+                campaignId: campaignId,
+                rewardToken: rewardToken,
+                numberOfPeriods: extraNumberOfPeriods,
+                totalRewardAmount: 0,
+                maxRewardPerVote: 0
+            }),
+            targetChainId,
+            additionalGasLimit
+        );
+    }
+
+    function manageRewardPerVote(
+        uint256 newMaxRewardPerVote,
+        uint256 bridgeFee,
+        uint256 additionalGasLimit
+    ) external onlyOperator {
+        require(campaignId != 0, "Campaign not created");
+
+        ICampaingRemoteManager(campaignRemoteManager).manageCampaign{
+            value: bridgeFee
+        }(
+            ICampaingRemoteManager.CampaignManagementParams({
+                campaignId: campaignId,
+                rewardToken: rewardToken,
+                numberOfPeriods: 0,
+                totalRewardAmount: 0,
+                maxRewardPerVote: newMaxRewardPerVote
+            }),
+            targetChainId,
+            additionalGasLimit
+        );
+    }
+
+    function setCampaignId(uint256 _campaignId) external onlyOperator {
+        campaignId = _campaignId;
+    }
+
+    function setOperator(address _newOperator) external onlyGovernor {
+        operator = _newOperator;
+    }
+
+    function sendETH(address receiver) external onlyOperator {
+        payable(receiver).transfer(address(this).balance);
+    }
+
+    receive() external payable {}
+}

contracts/contracts/strategies/Generalized4626Strategy.sol

@@ -10,7 +10,6 @@ import { IERC4626 } from "../../lib/openzeppelin/interfaces/IERC4626.sol";
 import { IERC20, InitializableAbstractStrategy } from "../utils/InitializableAbstractStrategy.sol";
 
 contract Generalized4626Strategy is InitializableAbstractStrategy {
-
     /// @dev Replaced with an immutable variable
     // slither-disable-next-line constable-states
     address private _deprecate_shareToken;

contracts/contracts/strategies/Generalized4626USDTStrategy.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 interface IUSDT {
     // Tether's approve does not return a bool like standard IERC20 contracts
     // slither-disable-next-line erc20-interface
-    function approve(address _spender, uint _value) external;
+    function approve(address _spender, uint256 _value) external;
 }
 
 /**
@@ -20,10 +20,9 @@ contract Generalized4626USDTStrategy is Generalized4626Strategy {
      * and vaultAddress (OToken Vault contract), eg VaultProxy or OETHVaultProxy
      * @param _assetToken Address of the ERC-4626 asset token. eg frxETH or DAI
      */
-    constructor(
-        BaseStrategyConfig memory _baseConfig,
-        address _assetToken
-    ) Generalized4626Strategy(_baseConfig, _assetToken) {}
+    constructor(BaseStrategyConfig memory _baseConfig, address _assetToken)
+        Generalized4626Strategy(_baseConfig, _assetToken)
+    {}
 
     /// @dev Override for Tether as USDT does not return a bool on approve.
     /// Using assetToken.approve will fail as it expects a bool return value

contracts/deploy/mainnet/112_ousd_morpho_gauntlet_usdc.js

@@ -6,7 +6,7 @@ module.exports = deploymentWithGovernanceProposal(
     deployName: "112_ousd_morpho_gauntlet_usdc",
     forceDeploy: false,
     // forceSkip: true,
-    // reduceQueueTime: true,
+    reduceQueueTime: true,
     deployerIsProposer: false,
     // proposalId: "",
   },

contracts/deploy/mainnet/113_ousd_morpho_gauntlet_usdt.js

@@ -6,7 +6,7 @@ module.exports = deploymentWithGovernanceProposal(
     deployName: "113_ousd_morpho_gauntlet_usdt",
     forceDeploy: false,
     // forceSkip: true,
-    // reduceQueueTime: true,
+    reduceQueueTime: true,
     deployerIsProposer: false,
     // proposalId: "",
   },

contracts/deploy/mainnet/114_pool_booster_curve.js

@@ -0,0 +1,59 @@
+const addresses = require("../../utils/addresses");
+const { deploymentWithGovernanceProposal } = require("../../utils/deploy");
+
+module.exports = deploymentWithGovernanceProposal(
+  {
+    deployName: "114_pool_booster_curve",
+    forceDeploy: false,
+    // forceSkip: true,
+    reduceQueueTime: true,
+    deployerIsProposer: false,
+    proposalId: "",
+  },
+  async ({ deployWithConfirmation, withConfirmation }) => {
+    const { deployerAddr } = await getNamedAccounts();
+    const sDeployer = await ethers.provider.getSigner(deployerAddr);
+    console.log(`Using deployer account: ${deployerAddr}`);
+    // 1. Deploy proxy
+    const dCurvePoolBoosterProxy = await deployWithConfirmation(
+      "CurvePoolBoosterProxy"
+    );
+    const cCurvePoolBoosterProxy = await ethers.getContract(
+      "CurvePoolBoosterProxy"
+    );
+
+    // 2. Deploy implementation
+    const dCurvePoolBoosterImpl = await deployWithConfirmation(
+      "CurvePoolBooster",
+      [
+        42161, // Arbitrum chain id
+        addresses.mainnet.CampaignRemoteManager, // Campaign Remote Manager (VotemarketV2 entry point)
+        addresses.mainnet.OETHProxy, // To be modified with desired bribe token
+        addresses.mainnet.CurveOETHGauge, // To be modified with desired gauge
+      ]
+    );
+    console.log("dCurvePoolBoosterImpl: ", dCurvePoolBoosterImpl.address);
+    const cCurvePoolBooster = await ethers.getContractAt(
+      "CurvePoolBooster",
+      dCurvePoolBoosterProxy.address
+    );
+
+    // 3. Initialize
+    const initData = cCurvePoolBooster.interface.encodeFunctionData(
+      "initialize(address)",
+      [deployerAddr]
+    );
+
+    // 4. Initialize proxy
+    const initFunction = "initialize(address,address,bytes)";
+    await withConfirmation(
+      cCurvePoolBoosterProxy.connect(sDeployer)[initFunction](
+        dCurvePoolBoosterImpl.address,
+        addresses.mainnet.Timelock, // governor
+        initData // data for delegate call to the initialize function on the strategy
+      )
+    );
+
+    return {};
+  }
+);

contracts/test/_fixture.js

@@ -336,6 +336,17 @@ const defaultFixture = deployments.createFixture(async () => {
         morphoGauntletPrimeUSDTStrategyProxy.address
       );
 
+  const curvePoolBoosterProxy = isFork
+    ? await ethers.getContract("CurvePoolBoosterProxy")
+    : undefined;
+
+  const curvePoolBooster = isFork
+    ? await ethers.getContractAt(
+        "CurvePoolBooster",
+        curvePoolBoosterProxy.address
+      )
+    : undefined;
+
   let usdt,
     dai,
     tusd,
@@ -805,6 +816,7 @@ const defaultFixture = deployments.createFixture(async () => {
     morphoGauntletPrimeUSDCVault,
     morphoGauntletPrimeUSDTStrategy,
     morphoGauntletPrimeUSDTVault,
+    curvePoolBooster,
 
     // Flux strategy
     fluxStrategy,