morpho-org/morpho-blue-bundlers

Morpho Blue Bundlers

Morpho Blue Bundlers

Morpho Blue is a new lending primitive that offers better rates, high capital efficiency and extended flexibility to lenders & borrowers. morpho-blue-bundlers hosts the logic that builds alongside the core protocol like MetaMorpho and bundlers.

Structure

Each Bundler is a domain-specific abstract layer of contract that implements some functions that can be bundled in a single call by EOAs to a single contract. They all inherit from BaseBundler that enables bundling multiple function calls into a single multicall(bytes[] calldata data) call to the end bundler contract. Each chain-specific bundler is available under their chain-specific folder (e.g. ethereum).

Some chain-specific domains are also scoped to the chain-specific folder, because they are not expected to be used on any other chain (e.g. DAI and its specific permit function is only available on Ethereum - see EthereumPermitBundler).

User-end bundlers are provided in each chain-specific folder, instanciating all the intermediary domain-specific bundlers and associated parameters (such as chain-specific protocol addresses, e.g. EthereumBundlerV2).

Deployments

• EthereumBundler
• EthereumBundlerV2
• (TODO) AgnosticBundlerV2 on Base

Getting Started

Install dependencies with yarn.

Run tests with yarn test:forge --chain <chainid> (chainid can be 1 or 8453).

Note that the EthereumBundlerV2 has been deployed with 80 000 optimizer runs. To compile contracts with the same configuration, run FOUNDRY_PROFILE=ethereumBundlerV2 forge b.

Audits

All audits are stored in the audits' folder.

License

Bundlers are licensed under GPL-2.0-or-later, see LICENSE.

morpho-blue-bundlers's Issues

Revert in multicall

Why do revert early in this case?

https://github.com/morpho-labs/morpho-blue-periphery/blob/54603e29db3568996d8f47639615dfb25d981a24/contracts/BaseSelfMulticall.sol#L16

Change license to GPL v2

`_initiator` can be set to `Morpho` with a callback

Example:

1. Alice triggers bulker1 (sender = Alice)
2. In a callback Morpho triggers bulker1 to call bulker2 (sender = Morpho)
3. bulker1 delegate calls bulker2 (sender = Morpho)
4. bulker2 sets _initiator as Morpho

Am I missing something? What are the consequences?

Handle L2 sequencer downtime

https://docs.chain.link/data-feeds/l2-sequencer-feeds#overview

On removing a market make sure funds are withdrawn before

Plant some trees 🌳

Solidity pragmas are inconsistent with `morpho-blue`

          The other interfaces of this repo don't follow this convention... Maybe it's better to change that in a future PR?

Originally posted by @makcandrov in #113 (comment)

Update blue submodule to main

Harmonize oracle errors

1. Extract errors to Errors library
2. Harmonize checks in constructor

`BaseBundler` should expose a `skim` function

          Without `ERC20Bundler` any tokens lying on the protocol that are not supplied on blue would be lost no?

Originally posted by @MerlinEgalite in #113 (comment)

Use ssh gitmodules for blue

Remove oracles

We'll migrate oracles to periphery, but first let's merge everything into main to have all the last changes together

Expose PRICE_INVERSED for each adapter

In Uniswap oracles, I think it would be helpful for testing and deployment purposes to expose a PRICE_INVERSED getter for the uniswap adapters.

Think about fallback oracles

Check onchain boundaries on Chainlink

try/catch on set authorization

Goal: avoid reverting the whole batch of tx when an attacker frontruns the signature

Consider adding calldata reducing entry points

Similar to:

https://github.com/aave/aave-v3-core/blob/master/contracts/protocol/libraries/logic/CalldataLogic.sol
https://github.com/aave/aave-v3-core/blob/master/contracts/protocol/pool/L2Pool.sol

The idea is to reduce the calldata size as much as possible when on a rollup.

More info in morpho-org/morpho-blue#208

Chainlink library is using `startedAt` instead of `updatedAt` when checking for sequencer uptime

This was suggested by Chainlink's docs but I don't get why we'd use startedAt instead of updatedAt

Use `yarn` instead of `make`

Because you can extend commands on the fly

Create Pyth oracle

As a reference: morpho-org/morpho-blue#226

Fix CI

Should we create packages?

There will be different folders for differents use and personas

• bundlers
• MM
• liquidation modules
• borrowing modules
• ?

What is the reason of having private functions?

/* PRIVATE */

    /// @dev Gives the max approval to the Blue contract to spend the given `asset` if not already approved.
    function _approveMaxBlue(address asset) private {
        if (ERC20(asset).allowance(address(this), address(BLUE)) == 0) {
            ERC20(asset).safeApprove(address(BLUE), type(uint256).max);
        }
    }

Migrate oracles Uniswap and Chainlink

Replicate morpho-org/morpho-blue#169

Do we really want to separate `BaseBulker`, `SelfMulticall` and `BaseSelfMulticall`?

`callback` modifier could be an internal function

https://github.com/morpho-labs/morpho-blue-periphery/blob/c8eb91a67946410604912240f77734179a429caa/contracts/bulkers/MorphoBulker.sol#L34-L40

Extract bundler interfaces

Should we revert on 0 price?

          That makes me think that we may not want to revert on 0, wdyt?

Originally posted by @MerlinEgalite in morpho-org/morpho-blue-irm#12 (comment)

Should we revert? Return 0?

Missing oracle configuration

UniswapV3Oracle & Chainlink(L2)Oracle allow creating an oracle for the market C (collateral) / B (borrowable) from a feed providing the price of C in B. However, there is no contract that allows us to create one from a feed providing the price of B in C.

Bulkers cannot be deployed on all chains with the same address

In order to do this, we should:

• have Blue deployed to the same address on all chains
• have a bulker layer common to all chains

Which is not the case at least because of stETH and WETH included in EthereumBulker atm

callBulker does not provide context to bulker on who is msg.sender

https://github.com/morpho-labs/morpho-blue-periphery/blob/c8eb91a67946410604912240f77734179a429caa/contracts/bulkers/BaseBulker.sol#L28

The bulker relies on locking an initiator to provide privileged access to certain function parameters, which doesn't seem to be passed through to other bulkers. It seems that initiator from a callBulker call would be the calling bulker itself. This potentially limits the use cases of bulkers calling other bulkers. Am I mistaken? @Rubilmax

Inherit `ERC4626` in `EthereumBundler`

Documentation to add

          So there are 4 features:

1. Being able to supply all that's available before the callback
2. Being able to supply all that's available during the callback
3. Being able to supply a specific amount before the callback
4. Being able to supply a specific amount during the callback

The former code handles 1,3
This change allows to handle 1,3,4, do we agree?
Do you have an alternative implementation in mind that can solve all 4 of these usecases?

Originally posted by @Rubilmax in morpho-org/morpho-blue-irm#27 (comment)

Consider exposing delays

https://github.com/morpho-labs/morpho-blue-periphery/blob/b00d05618036d001523072b1b5386cfb0499a486/contracts/oracles/adapters/UniswapV3CollateralAdapter.sol#L15

https://github.com/morpho-labs/morpho-blue-periphery/blob/b00d05618036d001523072b1b5386cfb0499a486/contracts/oracles/adapters/UniswapV3BorrowableAdapter.sol#L15

Update `src` with latest bundler changes

Add ERC4626 compatibility for bulkers

Add Natspecs

Remove funds before removing a market

Bundler actions are not `payable`

While calling multicall delegatecalls the bundler, it forwards msg.sender & value but handler actions are not payable so it reverts

Found by @Jean-Grimal during testing

External functions from bundlers can be called by anyone

In order to protect users from unexpected behaviors of the bundlers, we may consider protecting external functions with onlySelf:

modifier onlySelf() {
  require(msg.sender == address(this));

  _;
}

However, this would not work with callbacks, because they are expected to be called by specific addresses. In all cases, we know they expected address to call callbacks (Morpho, Balancer, etc), so we can craft a similar, dedicated solution for each callback type

In any case, it doesn't threaten security because the bundler is expected to be stateless between txs

Multicall alternative

Perhaps not worth it:

• https://github.com/Vectorized/solady/blob/main/src/utils/Multicallable.sol
• https://github.com/morpho-org/morpho-utils/blob/main/src/DelegateCall.sol

Remove routers

We won't use them so let's clean the repo

Update blue submodule

Move MM contracts to a related folder

Think about the fee in MM

Remarks and questions on oracles

I'm going through the oracles and I have a few remarks and questions (I will add some along the way):

1. it seems that we need to write each adapter logic twice (ChainlinkCollateralAdapter/ChainlinkBorrowableAdapter... ), and the oracles themselves (UniswapV3ChainlinkOracle/ChainlinkUniswapV3Oracle...). Did someone thought about a way to not do that ?

It seems that adapters don't need to be written twice at least. For the oracles I don't think that we have an elegant solution

Refactor oracle

Oracles have too much specific logic. We should rework a bit that to abstract each feed specificities.

Using shares may end up supplying/supplying collateral/repaying overflow the bulker's balance

In order to address this, we ideally need morpho-org/morpho-blue#183
Otherwise we need to calculate interests to be accrued

Bulker to bundler

Delete useless files

• swaps
• ?