Maple Protocol Adapter

The Maple adapter enables the Yieldinator Facet to integrate with Maple Finance's undercollateralized lending protocol, allowing vaults to earn fixed-income yields by providing liquidity to Maple's lending pools.

Overview

Maple Finance is a decentralized corporate credit market that connects institutional borrowers with lenders through a DAO-managed infrastructure. The Maple adapter facilitates deposits into Maple's lending pools, manages liquidity positions, and harvests yield from loan interest payments and MPL rewards.

Implementation Details

Contract: `MapleAdapter.sol`

The adapter implements the standard YieldinatorAdapter interface with Maple-specific functionality:

contract MapleAdapter is YieldinatorAdapter {
    using SafeERC20 for IERC20;
    
    // Maple contracts
    address public mplToken; // Maple governance token
    address public xMPL; // Staked MPL token
    IMapleStaking public mapleStaking; // MPL staking contract
    
    // Pool configuration
    struct PoolConfig {
        address pool; // Maple pool address
        address poolToken; // Pool token (LP token)
        bool stakeMPL; // Whether to stake MPL rewards
        bool active; // Whether the pool is active
    }
    
    // Mapping from token to pool configuration
    mapping(address => PoolConfig) public tokenToPool;
    
    // Deposited amounts per token
    mapping(address => uint256) public depositedAmount;
    
    // Constructor
    constructor(
        address _admin,
        address _mplToken,
        address _xMPL,
        address _mapleStaking
    ) YieldinatorAdapter("Maple Finance", _admin) {
        require(_mplToken != address(0), "MapleAdapter: MPL token cannot be zero address");
        require(_xMPL != address(0), "MapleAdapter: xMPL token cannot be zero address");
        require(_mapleStaking != address(0), "MapleAdapter: staking contract cannot be zero address");
        
        mplToken = _mplToken;
        xMPL = _xMPL;
        mapleStaking = IMapleStaking(_mapleStaking);
    }
}

Key Functions

Pool Registration

Before using the adapter for a specific token, the pool must be registered:

function registerPool(
    address _token,
    address _pool,
    address _poolToken,
    bool _stakeMPL
) external onlyRole(ADMIN_ROLE) {
    require(_token != address(0), "MapleAdapter: token cannot be zero address");
    require(_pool != address(0), "MapleAdapter: pool cannot be zero address");
    require(_poolToken != address(0), "MapleAdapter: pool token cannot be zero address");
    
    // Create and store pool configuration
    PoolConfig memory config = PoolConfig({
        pool: _pool,
        poolToken: _poolToken,
        stakeMPL: _stakeMPL,
        active: true
    });
    
    tokenToPool[_token] = config;
    
    emit PoolRegistered(_token, _pool);
}

Deposit

The deposit function handles depositing assets into Maple's lending pools:

function deposit(address _token, uint256 _amount)
    external
    override
    onlyRole(YIELDINATOR_ROLE)
    nonReentrant
    returns (bool)
{
    require(_amount > 0, "MapleAdapter: amount must be greater than 0");
    PoolConfig memory config = tokenToPool[_token];
    require(config.active, "MapleAdapter: pool not active for token");
    
    // Transfer token from caller
    IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
    
    // Approve pool to use tokens
    IERC20(_token).safeApprove(config.pool, _amount);
    
    // Deposit into Maple pool
    uint256 balanceBefore = IERC20(config.poolToken).balanceOf(address(this));
    IMaplePool(config.pool).deposit(_amount);
    uint256 balanceAfter = IERC20(config.poolToken).balanceOf(address(this));
    
    // Calculate pool tokens received
    uint256 poolTokensReceived = balanceAfter - balanceBefore;
    require(poolTokensReceived > 0, "MapleAdapter: no pool tokens received");
    
    // Update deposited amount
    depositedAmount[_token] += _amount;
    
    emit Deposited(_token, _amount);
    return true;
}

Withdraw

The withdraw function handles withdrawing assets from Maple's lending pools:

function withdraw(address _token, uint256 _amount)
    external
    override
    onlyRole(YIELDINATOR_ROLE)
    nonReentrant
    returns (uint256)
{
    require(_amount > 0, "MapleAdapter: amount must be greater than 0");
    require(_amount <= depositedAmount[_token], "MapleAdapter: insufficient balance");
    
    PoolConfig memory config = tokenToPool[_token];
    require(config.active, "MapleAdapter: pool not active for token");
    
    // Calculate proportion of pool tokens to redeem
    uint256 poolTokenBalance = IERC20(config.poolToken).balanceOf(address(this));
    uint256 poolTokensToRedeem = poolTokenBalance * _amount / depositedAmount[_token];
    
    // Approve pool to use pool tokens
    IERC20(config.poolToken).safeApprove(config.pool, poolTokensToRedeem);
    
    // Withdraw from Maple pool
    uint256 balanceBefore = IERC20(_token).balanceOf(address(this));
    IMaplePool(config.pool).withdraw(poolTokensToRedeem);
    uint256 balanceAfter = IERC20(_token).balanceOf(address(this));
    
    // Calculate amount received
    uint256 amountReceived = balanceAfter - balanceBefore;
    require(amountReceived > 0, "MapleAdapter: no tokens received");
    
    // Transfer withdrawn tokens to caller
    IERC20(_token).safeTransfer(msg.sender, amountReceived);
    
    // Update deposited amount
    depositedAmount[_token] -= _amount;
    
    emit Withdrawn(_token, amountReceived);
    return amountReceived;
}

Harvest Yield

The harvestYield function collects MPL rewards and optionally stakes them:

function harvestYield(address _token)
    external
    override
    onlyRole(YIELDINATOR_ROLE)
    nonReentrant
    returns (uint256)
{
    PoolConfig memory config = tokenToPool[_token];
    require(config.active, "MapleAdapter: pool not active for token");
    
    // Claim MPL rewards from the pool
    IMaplePool(config.pool).claim();
    
    return _harvestMPLRewards(config);
}

function _harvestMPLRewards(PoolConfig memory config) internal returns (uint256) {
    uint256 mplBalance = IERC20(mplToken).balanceOf(address(this));
    
    // If staking MPL rewards is enabled, stake in Maple staking contract
    if (config.stakeMPL && mplBalance > 0) {
        IERC20(mplToken).safeApprove(address(mapleStaking), mplBalance);
        mapleStaking.stake(mplBalance);
        
        // Calculate xMPL received
        uint256 xMPLBalance = IERC20(xMPL).balanceOf(address(this));
        emit YieldHarvested(mplToken, mplBalance, xMPL, xMPLBalance);
        return xMPLBalance;
    } else if (mplBalance > 0) {
        // Transfer MPL rewards to caller
        IERC20(mplToken).safeTransfer(msg.sender, mplBalance);
        emit YieldHarvested(mplToken, mplBalance, address(0), 0);
        return mplBalance;
    }
    
    return 0;
}

Emergency Withdraw

The emergencyWithdraw function provides a safety mechanism to withdraw all funds:

function emergencyWithdraw(address _token)
    external
    override
    onlyRole(ADMIN_ROLE)
    nonReentrant
    returns (uint256)
{
    PoolConfig memory config = tokenToPool[_token];
    require(config.active, "MapleAdapter: pool not active for token");
    
    // Withdraw all pool tokens from Maple pool
    uint256 poolTokenBalance = IERC20(config.poolToken).balanceOf(address(this));
    if (poolTokenBalance > 0) {
        IERC20(config.poolToken).safeApprove(config.pool, poolTokenBalance);
        IMaplePool(config.pool).withdraw(poolTokenBalance);
    }
    
    // Transfer all token balance to caller
    uint256 tokenBalance = IERC20(_token).balanceOf(address(this));
    if (tokenBalance > 0) {
        IERC20(_token).safeTransfer(msg.sender, tokenBalance);
    }
    
    // Transfer all MPL and xMPL to caller
    uint256 mplBalance = IERC20(mplToken).balanceOf(address(this));
    if (mplBalance > 0) {
        IERC20(mplToken).safeTransfer(msg.sender, mplBalance);
    }
    
    uint256 xMPLBalance = IERC20(xMPL).balanceOf(address(this));
    if (xMPLBalance > 0) {
        IERC20(xMPL).safeTransfer(msg.sender, xMPLBalance);
    }
    
    // Reset deposited amount
    depositedAmount[_token] = 0;
    
    emit EmergencyWithdrawn(_token, tokenBalance);
    return tokenBalance;
}

APY Calculation

The getCurrentAPY function calculates the current APY for a token in the Maple pool:

function getCurrentAPY(address _token)
    external
    view
    override
    returns (uint256)
{
    PoolConfig memory config = tokenToPool[_token];
    if (!config.active) return 0;
    
    // Get base APY from Maple pool
    uint256 baseAPY = IMaplePool(config.pool).getCurrentInterestRate();
    
    // Calculate MPL rewards APY
    uint256 mplRewardsAPY = _calculateMPLRewardsAPY(config.pool);
    
    // Add additional APY from staking MPL if enabled
    uint256 stakingAPY = config.stakeMPL ? _calculateStakingAPY() : 0;
    
    // Combine APYs
    return baseAPY + mplRewardsAPY + stakingAPY;
}

function _calculateMPLRewardsAPY(address _pool) internal view returns (uint256) {
    // Calculate MPL rewards APY based on pool's reward rate and total value locked
    // Implementation depends on Maple's specific reward distribution mechanism
    return IMaplePool(_pool).getRewardsAPY();
}

function _calculateStakingAPY() internal view returns (uint256) {
    // Calculate staking APY based on xMPL growth rate
    return mapleStaking.getStakingAPY();
}

Get Total Deposited

The getTotalDeposited function returns the total amount of tokens deposited:

function getTotalDeposited(address _token)
    external
    view
    override
    returns (uint256)
{
    return depositedAmount[_token];
}

Usage Example

Here's an example of how to use the Maple adapter with the Yieldinator Facet:

// Register the Maple adapter with the Yieldinator Facet
address mapleAdapter = address(new MapleAdapter(
    admin,
    mplToken,
    xMPL,
    mapleStaking
));
yieldinatorFacet.registerAdapter("Maple Finance", mapleAdapter);

// Register a pool for USDC
MapleAdapter(mapleAdapter).registerPool(
    USDC,
    USDC_POOL,
    USDC_POOL_TOKEN,
    true // Stake MPL rewards
);

// Add a yield strategy using the Maple adapter
yieldinatorFacet.addYieldStrategy(
    "Maple USDC Pool",
    mapleAdapter,
    USDC,
    3, // Medium-high risk level (undercollateralized lending)
    1200 // 12.00% APY
);

Security Considerations

Credit Risk: Maple Finance pools involve undercollateralized lending to institutional borrowers, which carries inherent credit risk.
Liquidity Risk: Withdrawals from Maple pools are subject to liquidity availability and may be delayed if the pool has insufficient funds.
Pool Delegate Risk: Maple pools are managed by Pool Delegates who make lending decisions, introducing potential governance risks.
Smart Contract Risk: The adapter interacts with multiple external contracts which may have vulnerabilities.

Risk Mitigation

The adapter implements strict access controls to prevent unauthorized access.
Emergency withdrawal functionality is available to recover funds in case of critical issues.
The adapter validates all inputs and handles edge cases to prevent unexpected behavior.
Integration with Maple's risk assessment framework to evaluate borrower creditworthiness.

Gas Optimization

The adapter minimizes gas usage by batching operations when possible.
For harvesting rewards, users can choose whether to stake MPL rewards based on gas costs and expected returns.
The adapter avoids unnecessary approvals by only approving tokens when needed.

Future Improvements

Support for Maple's credit default swaps (CDS) to hedge against default risk
Integration with Maple's governance system for participating in protocol decisions
Support for multiple pool delegates to diversify lending risk
Automated reinvestment of interest payments for compounding returns

PreviousLido Protocol Adapter NextRocket Pool Protocol Adapter