Manta deploy

Makefile

@@ -568,6 +568,10 @@ set-liquidation-threshold:
 set-reserve-factor:
 	make TASK_NAME=set-reserve-factor run-task
 
+.PHONY: reset-all-asset-reserve-factor
+reset-all-asset-reserve-factor:
+	make TASK_NAME=reset-all-asset-reserve-factor run-task
+
 .PHONY: set-interest-rate-strategy
 set-interest-rate-strategy:
 	make TASK_NAME=set-interest-rate-strategy run-task

contracts/apestaking/P2PPairStaking.sol

@@ -13,6 +13,8 @@ import {IERC721} from "../dependencies/openzeppelin/contracts/IERC721.sol";
 import {IERC20, SafeERC20} from "../dependencies/openzeppelin/contracts/SafeERC20.sol";
 import {PercentageMath} from "../protocol/libraries/math/PercentageMath.sol";
 import {SignatureChecker} from "../dependencies/looksrare/contracts/libraries/SignatureChecker.sol";
+import {Errors} from "../protocol/libraries/helpers/Errors.sol";
+import {IDelegateRegistry} from "../dependencies/delegation/IDelegateRegistry.sol";
 
 contract P2PPairStaking is
     Initializable,
@@ -47,6 +49,7 @@ contract P2PPairStaking is
     address internal immutable apeCoin;
     address internal immutable cApe;
     ApeCoinStaking internal immutable apeCoinStaking;
+    address internal immutable delegateRegistry;
 
     bytes32 internal DOMAIN_SEPARATOR;
     mapping(bytes32 => ListingOrderStatus) public listingOrderStatus;
@@ -58,6 +61,8 @@ contract P2PPairStaking is
     uint256 private baycMatchedCap;
     uint256 private maycMatchedCap;
     uint256 private bakcMatchedCap;
+    //asset => tokenId => delegateTo
+    mapping(address => mapping(uint256 => address)) tokenDelegations;
 
     constructor(
         address _bayc,
@@ -68,7 +73,8 @@ contract P2PPairStaking is
         address _nBakc,
         address _apeCoin,
         address _cApe,
-        address _apeCoinStaking
+        address _apeCoinStaking,
+        address _delegateRegistry
     ) {
         bayc = _bayc;
         mayc = _mayc;
@@ -79,6 +85,7 @@ contract P2PPairStaking is
         apeCoin = _apeCoin;
         cApe = _cApe;
         apeCoinStaking = ApeCoinStaking(_apeCoinStaking);
+        delegateRegistry = _delegateRegistry;
     }
 
     function initialize() public initializer {
@@ -117,6 +124,78 @@ contract P2PPairStaking is
         }
     }
 
+    function clearDelegation(address nft, uint256 tokenId) external {
+        require(
+            msg.sender == nBayc || msg.sender == nMayc || msg.sender == nBakc,
+            Errors.INVALID_CALLER
+        );
+        _clearDelegation(nft, tokenId);
+    }
+
+    function _clearDelegation(address nft, uint256 tokenId) internal {
+        bool delegated = (tokenDelegations[nft][tokenId] != address(0));
+        if (delegated) {
+            _updateTokenDelegation(
+                nft,
+                tokenId,
+                tokenDelegations[nft][tokenId],
+                false
+            );
+        }
+    }
+
+    function delegateForToken(
+        address nft,
+        uint256[] calldata tokenIds,
+        address delegateTo,
+        bool value
+    ) external nonReentrant {
+        address nTokenAddress;
+        if (nft == bayc) {
+            nTokenAddress = nBayc;
+        } else if (nft == mayc) {
+            nTokenAddress = nMayc;
+        } else if (nft == bakc) {
+            nTokenAddress = nBakc;
+        } else {
+            revert("unsupported");
+        }
+        IERC721 nToken = IERC721(nTokenAddress);
+        for (uint256 index = 0; index < tokenIds.length; index++) {
+            require(
+                msg.sender == nToken.ownerOf(tokenIds[index]),
+                Errors.INVALID_CALLER
+            );
+
+            bool isDelegated = (tokenDelegations[nft][tokenIds[index]] !=
+                address(0));
+            require(value != isDelegated, Errors.TOKEN_ALREADY_DELEGATED);
+
+            _updateTokenDelegation(nft, tokenIds[index], delegateTo, value);
+        }
+    }
+
+    function _updateTokenDelegation(
+        address asset,
+        uint256 tokenId,
+        address delegateTo,
+        bool value
+    ) internal {
+        if (value) {
+            tokenDelegations[asset][tokenId] = delegateTo;
+        } else {
+            delete tokenDelegations[asset][tokenId];
+        }
+
+        IDelegateRegistry(delegateRegistry).delegateERC721(
+            delegateTo,
+            asset,
+            tokenId,
+            "",
+            value
+        );
+    }
+
     function cancelListing(
         ListingOrder calldata listingOrder
     ) external nonReentrant {
@@ -326,7 +405,7 @@ contract P2PPairStaking is
                 apeCoinStaking.withdrawBAKC(_otherPairs, _nfts);
             }
         }
-        //5 transfer token
+        //5 transfer token and clear delegation
         uint256 matchedCount = apeMatchedCount[order.apeToken][
             order.apeTokenId
         ];
@@ -336,6 +415,7 @@ contract P2PPairStaking is
                 apeNToken,
                 order.apeTokenId
             );
+            _clearDelegation(order.apeToken, order.apeTokenId);
         }
         apeMatchedCount[order.apeToken][order.apeTokenId] = matchedCount - 1;
 
@@ -349,6 +429,7 @@ contract P2PPairStaking is
                 nBakc,
                 order.bakcTokenId
             );
+            _clearDelegation(bakc, order.bakcTokenId);
         }
 
         //6 reset ape coin listing order status

contracts/interfaces/IP2PPairStaking.sol

@@ -173,4 +173,11 @@ interface IP2PPairStaking {
      * @param _matchingOperator The address of the new matching operator
      */
     function setMatchingOperator(address _matchingOperator) external;
+
+    /**
+     * @notice clear delegation.
+     * @param nft The address of nft
+     * @param tokenId The token Id of nft
+     */
+    function clearDelegation(address nft, uint256 tokenId) external;
 }

contracts/protocol/pool/DefaultReserveAuctionStrategy.sol

@@ -33,7 +33,7 @@ contract DefaultReserveAuctionStrategy is IReserveAuctionStrategy {
     /**
      * Expressed in PRBMath.SCALE
      **/
-    uint256 internal immutable _minPriceMultiplier;
+    uint256 internal _minPriceMultiplier;
 
     /**
      * Expressed in PRBMath.SCALE
@@ -47,6 +47,8 @@ contract DefaultReserveAuctionStrategy is IReserveAuctionStrategy {
 
     uint256 internal immutable _tickLength;
 
+    address public owner;
+
     constructor(
         uint256 maxPriceMultiplier,
         uint256 minExpPriceMultiplier,
@@ -61,6 +63,12 @@ contract DefaultReserveAuctionStrategy is IReserveAuctionStrategy {
         _stepLinear = stepLinear;
         _stepExp = stepExp;
         _tickLength = tickLength;
+        owner = msg.sender;
+    }
+
+    function setMinPriceMultiplier(uint256 minPriceMultiplier) external {
+        require(msg.sender == owner);
+        _minPriceMultiplier = minPriceMultiplier;
     }
 
     function getMaxPriceMultiplier() external view returns (uint256) {

contracts/protocol/pool/DefaultReserveInterestRateStrategy.sol

@@ -9,6 +9,7 @@ import {IReserveInterestRateStrategy} from "../../interfaces/IReserveInterestRat
 import {IPoolAddressesProvider} from "../../interfaces/IPoolAddressesProvider.sol";
 import {IToken} from "../../interfaces/IToken.sol";
 import {Errors} from "../libraries/helpers/Errors.sol";
+import {MathUtils} from "../libraries/math/MathUtils.sol";
 
 /**
  * @title DefaultReserveInterestRateStrategy contract
@@ -103,12 +104,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
     }
 
     /// @inheritdoc IReserveInterestRateStrategy
-    function getMaxVariableBorrowRate()
-        external
-        view
-        override
-        returns (uint256)
-    {
+    function getMaxVariableBorrowRate() public view override returns (uint256) {
         return
             _baseVariableBorrowRate + _variableRateSlope1 + _variableRateSlope2;
     }
@@ -173,4 +169,9 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
 
         return (vars.currentLiquidityRate, vars.currentVariableBorrowRate);
     }
+
+    function calculateMaxYearAPY() external view returns (uint256) {
+        uint256 maxRate = getMaxVariableBorrowRate();
+        return MathUtils.calculateCompoundedInterest(maxRate, 0, 31536000);
+    }
 }

contracts/protocol/tokenization/NTokenApeStaking.sol

@@ -10,6 +10,7 @@ import {IRewardController} from "../../interfaces/IRewardController.sol";
 import {ApeStakingLogic} from "./libraries/ApeStakingLogic.sol";
 import "../../interfaces/INTokenApeStaking.sol";
 import {DataTypes} from "../libraries/types/DataTypes.sol";
+import {IP2PPairStaking} from "../../interfaces/IP2PPairStaking.sol";
 
 /**
  * @title ApeCoinStaking NToken
@@ -118,6 +119,7 @@ abstract contract NTokenApeStaking is NToken, INTokenApeStaking {
                 bakcNToken: getBAKCNTokenAddress()
             })
         );
+        _clearP2PDelegationInfo(tokenId);
         super._transfer(from, to, tokenId, validate);
     }
 
@@ -170,6 +172,13 @@ abstract contract NTokenApeStaking is NToken, INTokenApeStaking {
         );
     }
 
+    function setP2PPairStaking(address p2PStaking) external onlyPoolAdmin {
+        ApeStakingLogic.executeSetP2PPairStaking(
+            apeStakingDataStorage(),
+            p2PStaking
+        );
+    }
+
     function apeStakingDataStorage()
         internal
         pure
@@ -231,4 +240,14 @@ abstract contract NTokenApeStaking is NToken, INTokenApeStaking {
     function getBAKCNTokenAddress() internal view returns (address) {
         return POOL.getReserveData(address(getBAKC())).xTokenAddress;
     }
+
+    function _clearP2PDelegationInfo(uint256 tokenId) internal {
+        address p2PStaking = apeStakingDataStorage().p2PStaking;
+        if (p2PStaking != address(0)) {
+            IP2PPairStaking(p2PStaking).clearDelegation(
+                _ERC721Data.underlyingAsset,
+                tokenId
+            );
+        }
+    }
 }

contracts/protocol/tokenization/NTokenBAKC.sol

@@ -12,6 +12,7 @@ import {INTokenApeStaking} from "../../interfaces/INTokenApeStaking.sol";
 import {ApeCoinStaking} from "../../dependencies/yoga-labs/ApeCoinStaking.sol";
 import {INToken} from "../../interfaces/INToken.sol";
 import {IRewardController} from "../../interfaces/IRewardController.sol";
+import {IP2PPairStaking} from "../../interfaces/IP2PPairStaking.sol";
 import {DataTypes} from "../libraries/types/DataTypes.sol";
 
 /**
@@ -23,6 +24,7 @@ contract NTokenBAKC is NToken {
     ApeCoinStaking immutable _apeCoinStaking;
     address private immutable nBAYC;
     address private immutable nMAYC;
+    address public p2PStaking;
 
     /**
      * @dev Constructor.
@@ -71,13 +73,18 @@ contract NTokenBAKC is NToken {
         IERC721(underlyingAsset).setApprovalForAll(address(POOL), true);
     }
 
+    function setP2PPairStaking(address _p2PStaking) external onlyPoolAdmin {
+        p2PStaking = _p2PStaking;
+    }
+
     function _transfer(
         address from,
         address to,
         uint256 tokenId,
         bool validate
     ) internal override {
         _unStakePairedApePosition(tokenId);
+        _clearP2PDelegationInfo(tokenId);
         super._transfer(from, to, tokenId, validate);
     }
 
@@ -140,6 +147,15 @@ contract NTokenBAKC is NToken {
         return positionExisted;
     }
 
+    function _clearP2PDelegationInfo(uint256 tokenId) internal {
+        if (p2PStaking != address(0)) {
+            IP2PPairStaking(p2PStaking).clearDelegation(
+                _ERC721Data.underlyingAsset,
+                tokenId
+            );
+        }
+    }
+
     function getXTokenType() external pure override returns (XTokenType) {
         return XTokenType.NTokenBAKC;
     }

contracts/protocol/tokenization/libraries/ApeStakingLogic.sol

@@ -27,6 +27,7 @@ library ApeStakingLogic {
 
     struct APEStakingParameter {
         uint256 unstakeIncentive;
+        address p2PStaking;
     }
     event UnstakeApeIncentiveUpdated(uint256 oldValue, uint256 newValue);
 
@@ -86,6 +87,16 @@ library ApeStakingLogic {
         }
     }
 
+    function executeSetP2PPairStaking(
+        APEStakingParameter storage stakingParameter,
+        address p2PStaking
+    ) external {
+        address oldValue = stakingParameter.p2PStaking;
+        if (oldValue != p2PStaking) {
+            stakingParameter.p2PStaking = p2PStaking;
+        }
+    }
+
     struct UnstakeAndRepayParams {
         IPool POOL;
         ApeCoinStaking _apeCoinStaking;

hardhat.config.ts

@@ -267,6 +267,16 @@ const hardhatConfig: HardhatUserConfig = {
       url: NETWORKS_RPC_URL[eEthereumNetwork.mainnet],
       accounts: DEPLOYER,
     },
+    manta: {
+      chainId: CHAINS_ID[eEthereumNetwork.manta],
+      url: NETWORKS_RPC_URL[eEthereumNetwork.manta],
+      accounts: DEPLOYER,
+    },
+    mantaTest: {
+      chainId: CHAINS_ID[eEthereumNetwork.mantaTest],
+      url: NETWORKS_RPC_URL[eEthereumNetwork.mantaTest],
+      accounts: DEPLOYER,
+    },
   },
   etherscan: {
     apiKey: {
@@ -277,7 +287,6 @@ const hardhatConfig: HardhatUserConfig = {
       arbitrum: ARBITRUM_ETHERSCAN_KEY,
       arbitrumGoerli: ARBITRUM_GOERLI_ETHERSCAN_KEY,
       arbitrumSepolia: ARBITRUM_SEPOLIA_ETHERSCAN_KEY,
-      parallelDev: PARALLEL_DEV_ETHERSCAN_KEY,
       polygon: POLYGON_ETHERSCAN_KEY,
       polygonMumbai: POLYGON_MUMBAI_ETHERSCAN_KEY,
       polygonZkevm: POLYGON_ZKEVM_ETHERSCAN_KEY,
@@ -288,6 +297,7 @@ const hardhatConfig: HardhatUserConfig = {
       lineaGoerli: LINEA_GOERLI_ETHERSCAN_KEY,
       neon: NEON_ETHERSCAN_KEY,
       parallel: PARALLEL_ETHERSCAN_KEY,
+      parallelDev: PARALLEL_DEV_ETHERSCAN_KEY,
     },
     customChains: [
       eEthereumNetwork.localhost,