How’s your bera market, folks? We at Mellow think it’s a great time to build and focus on tech.

Our main goal is to create a robust ecosystem for building DeFi strategies — provide users top-notch safe yield-generating products built on top of Mellow and help other protocols to get sustainable funds and pools management.

Sooo… The Day is coming! Yes, we’re ready to show you what our team has been building for more than a year. We’re announcing Mellow Protocol launch!
The protocol is deployed and will be launched for the first users on November 17th.
Mellow will be available on Ethereum mainnet first.

Launch details

We want to bring the best experience to our users and will start with limitations that will help to gather feedback and make the launch more robust.

Here’re the raw facts:

• Date — November 17th
• Initial TVL limits — 500k per strategy, will be increased gradually after the launch
• Gated access — LobsterDAO NFTs and DegenScore Beacons holders
• Gated access period — ~1 month

Strategies

At the launch, strategies with completely different approaches will be available — Boosted UniV3 and Fearless Gearbox. Also, Mellow already has a strategy built on top of the protocol by Voltz Protocol — Mellow-Voltz LP Optimizooor, we’re excited that our vaults already help other protocols to build their strategies.

Boosted UniV3

Boosted UniV3 strategy provides a risk profile very similar to a fixed UniV3 position but with higher returns by the combination of UniV3 and Yearn.

Consider UniV3 ETH/USDC 0.05% pool and assume we’d like to put our liquidity into the [1000, 2000] price range (we refer to it as the Domain price range). How can we do better than just providing it directly into the pool?

The trick is to put only a tiny portion of liquidity into a really narrow price range earning the same fees as direct providing. As soon as the price risks going out of the narrow range, rebalance the interval to cover the price safely.

The liquidity requirements for UniV3, in this case, are significantly lower. The rest of the liquidity is allocated to Yearn. Thus the overall returns are higher for the UniV3 Boosted strategy.

Concentrated liquidity and swaps risks

The strategy has the same risk as the underlying UniV3 position with the Domain price range with one exception: if the rebalance happens when the price is out of the narrow price range. In this case, there are two key differences:

1. Boosted UniV3 swaps at a better price than UniV3
2. UniV3 gets fees for the swap, Boosted UniV3 pays fees for the swap

Generally, a better price gives much more benefit than fees loss so Boosted UniV3 will perform better than UniV3. However, there are some edge cases when the price move is too little to compensate for the loss of the fees. In these rare cases, the Boosted UniV3 position will perform slightly worse.

For more details and formulas see our article about the tricks with Uniswap V3:

Uniswap V3 Voodoo Magic Fuckery

Fearless Gearbox

This strategy allocates the tokens into Gearbox Protocol to get the leverage and puts them into the Curve pool. Then the strategy deposits Curve LP tokens into Convex where the juicy yields live.

The strategy implements the backstop module:

The backstop module monitors the position’s health factor and has pre-defined deployment parameters when the strategy can be stopped. Under the specific market conditions, Backstop Module automatically triggers Closing Credit Account to avoid liquidations.

For more details see the detailed article on the Fearless Gearbox:

Fearless Gearbox strategy by Mellow

Mellow-Voltz LP Optimizer

The strategy was built by Voltz Protocol, and we’re proud that the team chose Mellow to work on their strategy, details are described in the article in Voltz Protocol blog:

Introducing the Mellow-Voltz LP Optimizooor

Voltz Labs ⚡️ on Twitter: "Today we're announcing the launch of the @Mellowprotocol LP Optimisoor - allowing traders to passively LP on Voltz Protocol without the risk of impermanent loss (and generating >30% APY in backtested results!)Here's why we're excited about this launch 👇 pic.twitter.com/jsKCN7cxcu / Twitter"

Today we're announcing the launch of the @Mellowprotocol LP Optimisoor - allowing traders to passively LP on Voltz Protocol without the risk of impermanent loss (and generating >30% APY in backtested results!)Here's why we're excited about this launch 👇 pic.twitter.com/jsKCN7cxcu

The trick — it’s already live and can be used via Voltz dapp interface.

Code & audits

Our codebase is available on GitHub, feel free to check it out and ask any question in our Discord #💻dev section.

The protocol core was audited by Chainsecurity and BlockSec, the reports are published in Mellow GitHub.

Initial strategies are under audit right now and the reports will be published soon.

Protocols, integrations and further strategies

Besides the initial strategies, there’re more to come and some new strategies are already WIP and will be released soon.

We see Mellow not only as a solution for LPs, but also as a protocol for protocols that provides strategies for native protocol tokens and treasury management.

As an integration layer, we’re open to collaboration and integration with any protocols, feel free to contact us in Discord if you want to discuss your strategy ideas or have requests for integrations to implement your strategy.

Ping us and let's buidl together!

Get involved

To get involved join the discussion in Mellow Discord, share your ideas and check the protocol on Nov 17th.

Contribute with your fresh, juicy, composable ideas and share your feedback!

Twitter | Discord | Docs | Website

Mellow Protocol sees itself as an integration layer for DeFi that enables building automated strategies integrated with best-in-class protocols.

We love building composable stuff as it’s one of the key benefits of programmable money. That’s why we were interested in Gearbox, as it provides inventory for programmable leveraged strategies. This allows you to increase the capital efficiency of many strategies.

Gearbox is a generalized leverage protocol. It allows anyone to take DeFi-native leverage and then use it across various (DeFi & more) protocols to earn leveraged yields, this enables you to compose your position as you want. You can find more details in Gearbox docs.

We implemented integration with Gearbox — our Leveraged Vault. It allows strategists to easily program leveraged strategies for different protocols using Gearbox Credit Accounts — all of these can be provided for strategists as a ready solution that can be deployed as an end-user product. The goal of the strategist here is to manage the strategy’s risks. Here’s the list of parameters that can be managed to achieve that:

• Set the type of collateral provided to the vault (choose once per initialization)
• Leverage coefficient (choose once per initialization)
• Vault funds allocation (choose once per initialization)
• Backstop parameters

Let’s first see the diagram showing how everything works:

Strategy

This strategy allocates your assets into Gearbox and leverages them to put into the Curve pool, then deposits your Curve LP tokens into Convex where you get your juicy yields.

Backstop module

The backstop module monitors the position’s health factor and has pre-defined deployment parameters when the strategy can be stopped. If market conditions correspond to these parameters Backstop Module automatically triggers Closing Credit Account to avoid liquidations.

Maintaining position

Not everyone can implement the appropriate infrastructure to automate maintaining the position. Tracking it manually is also not easy — we all need to sleep at least sometimes. While leveraging is also challenging — sometimes quite low depeg can lead to liquidation.

Risk management

Any on-chain implementation of leverage has some hidden effects — for example, oracle’s deviation:

Gearbox ⚙️🧰 V2 LIVE on Twitter: "Check the oracles section to understand that Gearbox uses @chainlink $USD oracles. So when you are dealing with $ETH debt $stETH position, Chainlink price tick is different for both & might cause liquidation even if stETH doesn't actually depeg relative to ETH. Count that in! pic.twitter.com/hhVqjw8dtK / Twitter"

Check the oracles section to understand that Gearbox uses @chainlink $USD oracles. So when you are dealing with $ETH debt $stETH position, Chainlink price tick is different for both & might cause liquidation even if stETH doesn't actually depeg relative to ETH. Count that in! pic.twitter.com/hhVqjw8dtK

Estimation of such kind of risks needs the expertise to keep your assets safe.

Low entry threshold

In fact, Vault represents a tokenized index for leveraged strategy — the user can easily get into such a complex derivative product, while an external party manages the risk. For example, such an index can later be used as an infrastructure for building leveraged indices (IndexCoop team, we got something to discuss👀).

What are the benefits of such leveraged vault strategies for end users:

• 1-click deposit without opening the credit account
• No need to monitor 24x7 your position liquidation status
• Users don’t need to wait to get access to Gearbox

Strategies we’re building as an example

Current strategy:

• Leveraged FraxUSDC, collateral USDC

Upcoming strategies:

• Leveraged LIDO, collateral ETH
• Leveraged LIDO, collateral USDC

The most curious Degens who read our articles until the end could wonder when we will launch the protocol and this pretty strategy. Well, we won’t make you wait for long, it’s less than ten days left until Mellow Protocol launch. The announcement is coming!

Twitter | Discord | Gitbook | Website

After Uni V3 was announced in spring 2021, we came up with the idea of developing a permissionless liquidity rebalancing protocol. We started with our research on how to effectively manage the liquidity on Uni V3 and then expanded to a cross-protocol permissionless protocol vision.

As the Protocol is launching soon, we want to share our current progress, upcoming milestones, and of course, the details about our seed round.

Recap

We were working in a semi-stealth mode, and right now, as we are close to releasing our Protocol, we want to showcase a short recap of what we have achieved so far.

Product

• Permissionless vaults platform — our main effort and the core of the product
• First strategy contract
• Documentation for developers/strategists
• Performed internal tests with L2 live deployments

Research

• Backtesting SDK — we used it internally while developing the strategies and open-sourced it to the public recently
• Strategies — we designed effective strategies that can be deployed on the platform for multiple token pairs
• Data infrastructure — we built a robust infrastructure to enable researchers to get access to on-chain data while working on strategies rapidly

UI

• The user interface is ready for production deployment

Team

• Hired core team and contractors — our core team expanded to 12 people and we’re looking for new passionate Web3 contributors

Audits

• Completed audit with ChainSecurity
• Completed audit with BlockSec
• Completed Cod34r3n4 audit competition

Content & Community

• Released articles about LPing on UniV3, our Vaults system architecture, VMF strategy, and our backtesting SDK
• Launched Discord community

Seed round

In August 2021, Mellow Protocol closed a $2.75 million seed round led by Robot Ventures, Arrington Capital, and ParaFi.

Also, we’re super excited to see among our backers valuable funds, builders and community members:

• P2P Capital
• Lemniscap
• Focus Labs
• Principle Ventures
• Primitive Ventures
• NEMO Ventures (the friendly apes behind DegenScore)
• Darren Lau (The Daily Ape, Not3Lau Capital)
• Daryl Lau (Not3Lau Capital)
• Santiago R Santos (#9159)
• Jamis Johnson (PleasrDAO)
• Igor Barinov (Blockscout/xDai chain)
• Ivangbi (Gearbox & LobsterDAO)
• Yearn сore contributor
• Mariano Conti (ex-MakerDAO)
• Molly (eGirl capital)
• Shadowy super coders who want to stay anonymous

The community already gives us a lot of valuable feedback and wise advice. The goal of the current funding round is to develop and bootstrap the Protocol.

Protocol launch

Our primary focus is to get live – we’re working on final preparations before the launch.

Next steps:

• UI deployment
• Guarded launch of the Protocol and initial strategies in Mainnet
• Integrations & L2 deployments
• Strategist UI
• V2 design

As we’re going to be live soon — keep an eye on our media and don’t miss the official launch announcement👀

Twitter | Discord | Gitbook | Website

The DeFi landscape is rapidly becoming more complex. In terms of products and structure, it is becoming similar to the TradFi ecosystem, only built on fundamentally different rails: transparency, control of your funds, and privacy.

However, the DeFi ecosystem is still at the very early stages (like a 4-year-old kid), and some parts are still missing. One of these missing (or almost missing) parts is the analytical tools for DeFi space. Ofc you can say there is Dune and Nansen, which can be used as BI solutions, and Gauntlet for stress tests and simulations. But these tools can’t fill all the needs in DeFi analytics. Modeling and testing strategies are one of those places where analytic tools can be very useful.

Here at Mellow, we are building a platform that we hope can address this need and enable the creation of economically viable and validated asset management strategies. We already use this tool by ourselves to research market structure and look for highly profitable strategies. But Web3 is about open solutions. So today, we want to present you the Mellow SDK — an open-source (now!) solution for developing asset management strategies in DeFi. This SDK will allow to weigh the risk of strategies and their potential returns and, ultimately, allow for the creation of more structured products. And everyone will benefit from this — strategists, liquidity providers, and the entire market.

New Challenges

Blockchain systems are at the intersection of technology and finance. While we believe that blockchain technology opens up a new paradigm shift in the way people interact, we are also convinced that it creates a new set of challenges not found in traditional finance:

• Transaction costs (even though gas prices in 2022 fell compared to 2021, it is imperative to consider gas costs and other losses when making transactions)
• In distributed and open networks, the behavior of the system and the experience of using the software is determined not only by the strategist. There are a lot of different effects that should be taken into account while building a strategy: other participants’ actions, hacker attacks, and market manipulations (JIT attacks, flash loan attacks, etc.)
• It is necessary to reproduce invariants and other algorithm parts that are often used in existing DeFi protocols (with the growth of Uniswap seems everyone knows x*y=k)

We at Mellow want to develop new standards that respond to these challenges and can form the basis for creating new and better strategies in DeFi.

Mellow SDK

Mellow SDK is an analytical tool that allows you to evaluate the profitability and risks of strategies based on historical data. The main focus of the Mellow SDK is functionality for working with DeFi tools, but it can also work with CeFi crypto services.

Using the Mellow SDK, you can create your algorithmic strategy for managing a portfolio that includes UniV3 positions, currency pairs, and deposits. The analysis tools implemented in the SDK allow you to calculate the performance metrics of your strategy and visualize them (for example, APY, impermanent loss, collected fees, portfolio value, etc.). Note that the framework is flexible for customization; you can add your own metric to the calculation.

The Mellow SDK allows you to use actual UniswapV3 pool data from Mellow Open Data storage, generate synthetic data based on Geometric Brownian Motion, or use your Binance API to download data from Binance.

Use cases

In this section, we will consider three strategies that allow you to evaluate the capabilities of the platform:

• LP-ing to Uniswap V2
• Passive LP-ing to Uniswap V3
• Active LP-ing to Uniswap V3

LPing to Uniswap V2

The visualization shows portfolio growth and APY you get.

LPing to Uniswap V3

You can select a price range to deposit funds in Uniswap and look at how it behaves on historical data. The issue here is that you know actual price fluctuations to predict prices. For example, you can get range [15,16] for WBTC/WETH pair and backtest this strategy:

The knowledge of future prices opens you great opportunity to grow your wealth. How sad that it works only on backtest🧐

Active LPing in Uniswap V3

You can say strategies that do nothing are boring and be right. So let’s build an active strategy.

For example, when the price is 60 minutes outside the interval, the strategy withdraws funds and puts it to a new very narrow interval — (price-0.3, price+ 0.3). That is, the interval will constantly chase the price. It is pretty clear that such a strategy can go bankrupt due to the cost of gas, so we put gas_cost=0 (what a joke! But it’s only a showcase).

You can see here how the interval changed, but unfortunately, this strategy did not get income even with 0 transaction costs since impermanent loss always stayed higher than earned fees:

How to work with SDK

This section will briefly describe how to work with the Mellow SDK. An example of a Jupiter notebook can be found on our GitHub.

We also recommend checking our documentation, where you can find more explanations, tutorials, and how to get started. And ofc ask any questions on Discord.

Setup

Create a virtual environment and install the package.

python3 -m venv .venv
source .venv/bin/activate
pip install mellow_strategy_sdk

Choose WBTC/WETH 0.3% pool

POOLS — dictionary with pools available in SDK. For example, choose WBTC/WETH pool with middle fees.

pool_num = 1
pool = Pool(
    tokenA=POOLS[pool_num]['token0'],
    tokenB=POOLS[pool_num]['token1'],
    fee=POOLS[pool_num]['fee']
)

Download data

Usually, extracting data correctly from blockchain has a lot of troubles (for example, the Graph has some gaps in the data, which can be critical for strategies backtest). Fortunately, we have already done that job for a large set of pools — you can simply download and use them.

Let’s load data from Mellow Open Data. The data consists of transactions (mint, burn, swap events) with UniswapV3. The data is updated once a day.

data = RawDataUniV3(pool=pool, data_dir='data').load_from_folder()

Data contains three data frames — data.mints, data.swaps, data.burns. Respectively, historical data on mint (deposit), burn (withdraw), and swap operations performed in the pool.

Use standard strategy

The strategies.py file contains some ready-made strategies that can be used as tutorials:

• Hold — buy & hold strategy
• UniV3Passive — mint to specified interval&wait
• StrategyByAddress — backtests actions in the pool at the wallet address

As the V2 interval corresponds to V3 (0, ∞), you can use UniV3Passive for V2 to

v2_strat = UniV3Passive(
    lower_price=1e-10,
    upper_price=1e10,
    pool=pool,
    gas_cost=0.1,
    name='passive_v2'
)

Backtest

The backtest sequentially passes historical data at each step feeding it to the input of the strategy, after which it takes a snapshot of the portfolio.

By the end of the backtest, we could remember the state of the portfolio at each point in time.

bt = Backtest(strategy=v2_strat)
portfolio_history, rebalance_history, uni_history = bt.backtest(df=data.swaps)

The Grand Plan

Our goal is to complete the ecosystem with universal vaults that everyone can use to build any strategies they want and deploy using Mellow infrastructure.

Initially, we developed the SDK for internal use, and now we make it public so every builder can use it for backtesting his strategies and ensuring that he’s on the right track.

We want to help the community build better products and strategies, and we’ll be happy to discuss your ideas or answer any questions on our Discord or Twitter.

Come! Build! Earn!

Twitter | Discord | Gitbook | Website

We worked hard on the smart contracts code and audits, as well as the new math models and strategies. As we’re getting closer to the launch (news on the release plans are also coming soon 👀), we’re making it up with new research materials for the community.

Today, we want to go down into the deepest deeps of Uniswap V3 and see if we can use some magic to extract some hidden value from it.

50% APY on WETH/USDC pool? Is it possible?

We want to invite you to our theoretical journey that starts 200 days back and spans over several acts. We’ll go back in time and see what we can learn from the past and how we can change the future. Are you ready? Then let’s start our 20-minute adventure from the beginning of the Uniswap V3 era (in and out, real quick).

Act 1 — The Riddle (long, long time ago…)

In early 2021, Uniswap V3 introduced the concept of concentrated liquidity to AMMs. Instead of providing liquidity on the entire price range of (0, ∞) (as any Uni V2 LP provider did), liquidity providers could now put their tokens into any price range they wanted. And since any price range is shorter than (0, ∞) they could earn more fees from that. Sounds cool, huh? Well, one thing seemed clear — not everyone was happy with it:

kain.eth L222 on Twitter: "Uniswap V3 nft positions inadvertently ruined yield farming, prove me wrong. / Twitter"

Uniswap V3 nft positions inadvertently ruined yield farming, prove me wrong.

Uniswap Labs was the first AMM to provide their LPs with powerful tools for liquidity optimization (they’re real innovators and big brains!). But all of a sudden, capital management on Uniswap V3 became challenging. Any liquidity provider would need to choose the best price range for liquidity provision. Impermanent loss, price risks, mempools… All these creepy details started to matter.

Professional market makers could seemingly deal with it and even extract more value using techniques like JIT. But what about the ones who only want to ape in and forget about it?

One way of doing it would be to put the liquidity onto the (0, ∞) range and forget about it. Wow, that’s a relief! But won’t that steal some precious APY %? Can we do a little bit better?

Wait… Wasn’t Sir Hayden talking exactly about this???

hayden.eth 🦄 on Twitter: "My favorite v3 vault design sounds a bit like a riddle:I always maintain a 50/50 allocation but still uses concentrated liquidity. I rebalance with no fees or permanent loss.What am I? / Twitter"

My favorite v3 vault design sounds a bit like a riddle:I always maintain a 50/50 allocation but still uses concentrated liquidity. I rebalance with no fees or permanent loss.What am I?

The answer to The Riddle is simple:

hayden.eth 🦄 on Twitter: "winner winnerTake on the 50-50 v2 position in v3 but keep tokens in the fringes in lending protocolsAs price moves rebalance by withdrawing/depositing from lending protocol and v3 position (no swap fee)same IL / same market neutral nature, but you also earning lending fees https://t.co/oLvDiQViVT / Twitter"

winner winnerTake on the 50-50 v2 position in v3 but keep tokens in the fringes in lending protocolsAs price moves rebalance by withdrawing/depositing from lending protocol and v3 position (no swap fee)same IL / same market neutral nature, but you also earning lending fees https://t.co/oLvDiQViVT

Here’s how it works in detail:

1. Break a UniV2 price curve into equal virtual price ranges
2. Put a portion of liquidity into the range which currently covers the current price
3. Put all other tokens into the yield protocols like Convex, Ribbon, and Yearn and earn additional yields
4. When the price goes from one range to another, pull liquidity from the former and put it into the latter

Now that we have understood the guts of Hayden’s strategy, let’s see how it works.

Lights, camera, action!

Sooooo… With just a handful of capital, we can exactly duplicate the UniV2 position but earn an additional yield on all other capital in your position. It seems like a huge win, but can we do even better?

Act 2 — The VooDoo Magic Fuckery (present days)

Ok, so we could beat UniV2 in the previous act. But can we beat UniV3 itself with UniV3? The answer is YES!

Unsurprisingly, for any UniV3 price range, we can:

1. Break a UniV3 price range into equal virtual price ranges
2. Put a portion of liquidity into the range which currently covers the current price
3. Put all other tokens into the yield protocols like Compound, Aave, and Yearn and earn additional yields
4. When the price goes from one range to another, pull liquidity from the former and put it into the latter

And here we go again with the almighty VMF strategy:

Here’s the actual magic spell with the correct ingredients:

Assume we provide liquidity on Uni V3 at interval [a0, b0] using 1 unit of wealth. Then concentrated UniV3 strategy will be

where u_1 — is part of liquidity provided to UniV3, u_2, u_3 — is part of liquidity provided to yield generated one-token strategies, [a,b] — subset of [a0,b0] such as a0<a<c0<b<b0, c0 — current price.

UniV3 beats UniV3, sounds pretty cool, right?

But before we conclude this act with a standing ovation, we need to address one more small detail here. If you read carefully, there’s one thing that might be lurking in your mind and make you feel uncomfortable — step 4 of the strategy.

“When the price goes from one range to another, pull liquidity from the former and put into the latter.” Well, we cannot trigger that on UniV3 price change on-chain, right? This has to be done with an external caller, keeper perhaps, that could miss the rebalance event, and the price can move far away from the price range with liquidity. And in that case, the strategy doesn’t work exactly like UniV3. Assume we had a 40% price crash on May 21 when ETH fell from x to y. We can imagine a Twitter thread coming:

To sum up, we have a VMF strategy that:

1. Earns the same fees as UniV3 position
2. Has additional yield by adding free liquidity into yield protocols like Compound, Aave, Yearn, etc.
3. IL protected when prices go mad

Act 3 — The Money (not too far distant future)

Ok, nuff said on math and formulas! Let’s address the elephant in the room, a small question that rules this world, a small question that drives all success — what’s in it for me?

It turns out that the APY for this strategy could reach a staggering 58% on USDC-WETH pair and 18% on WBTC-WETH pair:

Here APY for two-token strategy is calculated by 0xAlexEuler’s approach, which looks more valid for crypto investors (measuring APY in one of two tokens gets higher APY but easy for manipulations — read more in Twitter thread).

Now imagine what we can do next with that? A VMF strategy that beats plain UniV3 LPing. Build a vault that implements this strategy automatically, so it’s just set-and-forget for liquidity providers? Sure thing. But there’s more to it…

In fact, any active management strategy on top of UniV3 can be built on top of the VMF strategy and have… higher yield and… lower IL!

We want to leave this play open-ended. I know, I know, everyone hates open endings. But! They’re leaving more space for imagination, so rare these days!

Lately, we discussed the basics of liquidity providing mechanics on Uniswap V3 in our medium post. It was part of broader research on optimal liquidity provision on Uniswap V3 and other DeFi protocols we’ve been doing for the last months. The research brought us new insights into active liquidity routing strategies and system design, which will be covered in the next articles. Today, we’re going to show how we can actually implement the system for active liquidity balancing between protocols on the blockchain.

Key results of our research led us to the design of Mellow Permissionless Vaults — a system that allows flexible liquidity provision and liquidity management. In this article, we’d like to provide key highlights and encourage the community to have a design discussion on our Twitter and Discord.

If you want to dive into details and contract API check out our docs.

Let’s get started!

Featured highlights

There’re a lot of different aspects that should be considered when designing a vault system. We decided that we want to have the following features in Mellow Vaults:

1. Permissionless — anyone can create a new vault and deploy strategies to manage it;
2. Strategist friendly — strategists should be incentivized to create new strategies by earning fees;
3. Multitoken — strategies can manage multiple ERC-20 tokens at once;
4. Cross-protocol — liquidity can be routed to different DeFi protocols on Etheruem mainnet and on L2/sidechains;
5. Liquidity-mining enabled — liquidity in the Vault could be used to participate in liquidity mining programs thus earning additional yield for Mellow liquidity providers;
6. Strategy trustless — strategy should only be able to perform minimal actions that only allow to rebalance liquidity between protocols and tokens, not diverge it somewhere else. Thus it’s possible to deploy the Strategy both as a smart contract and as an off-chain management system;
7. Oracle adverse — reduce the number of oracles to a minimum since many DeFi hacks used oracle manipulation.

How it works

A typical vault and strategy setup would be made by using Mellow Permissioless Vaults deployVault function. As a result, the following set of smart contracts (called Vault System) would be established for every strategy and token pair:

For each DeFi protocol, a separate Vault contract is deployed. This allows depositing/withdrawing funds and tracking earnings for that protocol. These vaults are aggregated using Gateway Vault.

On top of that, there’s an LP Issuer contract that issues LP ERC-20 tokens to liquidity providers or NFT Issuer that issues ERC-721 tokens (Vault System configuration defines the type of contract/token).

The flow of the tokens between the contracts:

1. Liquidity provider deposits ERC-20 tokens into LP Issuer;
2. LP Issuer mints LP tokens to the liquidity provider;
3. ERC-20 tokens get transferred into the Gateway Vault, then it redistributes them into Integration layer vaults on a pro-rata basis;
4. Integration layer vaults put liquidity into DeFi protocols.

Strategy contract is a separate entity that is only allowed to redistribute liquidity between vaults and collect liquidity mining rewards (if any) from the underlying DeFi protocols. Technically, the Strategy is not required to be a contract but can also be an off-chain management system.

Vault system architecture

There are two types of contracts on the diagram:

1. Protocol contracts (pink color) — these are the protocol contracts that are deployed in one instance;
2. Vault contracts (purple color) — these are the contracts deployed by users (vault owners/strategists) by using protocol contracts. Essentially everyone can create a set of Vault contracts.

We can logically separate contracts into Vault Groups. Each Vault Group is a set of contracts that allows managing and creating a vault of a specific Vault Kind. Vault Governance is a contract that can:

1. Deploy a new vault via a VaultGovernance#deployVault method
2. Manage governance params for specific vaults

Upon Vault creation, the Vault Registry contract mints a new ERC-721 token that represents that Vault.

Strategists unite!

Mellow Protocol Vaults are permissionless by design. We believe in the power of builders and community and we welcome everyone to build liquidity management strategies with Mellow.

New Vault System can be easily created and deployed.

There are 3 core functions applicable to liquidity in the Vault contracts:

• Vault#push — pushes the ERC-20 tokens from the Vault balance to the underlying DeFi protocol;
• Vault#pull — pulls the ERC-20 tokens from the Underlying DeFi protocol to some other Vault of the Vault System;
• Vault#claimRewards — claim liquidity mining rewards for the Vault (if any are assumed by the underlying DeFi protocol). Note that contracts with the liquidity mining rewards should be whitelisted in the Protocol Governance.

For more details on managing Vaults and managing the liquidity check Strategist guide section in our docs.

After we finish the beta phase, we’re considering special incentives for Strategists who will actively build effective liquidity management strategies.

Next steps

We’re preparing for the launch and here’s our plan for the following months:

Nov’ 21: Finalize the design of the vaults, finish the development, release the first version of the protocol for internal testing on mainnet;

Dec’ 21: Code423n4 contest and first audit, guarded launch with cap limits;

Feb’22: Final audit, uncapped vaults launch, L2 experiments.

Join our Twitter and Discord to discuss Vaults design with the team and stay in the loop.

Twitter | Discord | Gitbook | Website

Hello there, no time for the pleasantries, let’s talk Uniswap V3 math!

We’re going to deep dive into how liquidity provision works in Uniswap v3 and how you can align the portfolio of 2 tokens so that your LP position yields the maximum fees while reducing IL to the minimum. Expect a lot of formulas and numbers.

Uniswap v2 recap: a trader’s perspective

Uniswap v2 is an automated market maker that allows:

• Traders to swap one asset for another;
• Liquidity providers (LPs) to provide liquidity and earn trading fees.

Each pool has 2 tokens: X and Y. If the pool holds xₚ tokens of X and yₚ tokens of Y (also called pool reserves), then pool liquidity L is defined by:

The current ratio of tokens in the pool defines the current swap price p:

If a trader wants to swap y tokens of Y, they deposit y tokens into the pool and receive x tokens of X back. x is defined by the pool using the following equation:

Here ϕ is a pool fee. For Uni v2, it’s 0.3%.

Now assume for a moment that ϕ = 0, and let’s see what happens if the current price p = 1, pool reserves xₚ = 1, yₚ = 1, and a trader wants to swap y = 1 units of Y token.

The trader will receive back x = 0.5 tokens of X. The pool reserves and price will update to xₚ = 0.5, yₚ = 2, p = 4.

We would expect x = 1 at current price p = 1 but the actual x amount is subject to loss known as slippage (sₗ = 0.5):

The good news is sₗ → 0 as pool liquidity L grows or swap amount decreases, i.e., for small enough swap amounts you exchange at price p fewer fees.

Uniswap v2 recap: a liquidity provider’s perspective

Now let’s see what happens if p = 4, pool reserves xₚ = 0.5, yₚ = 2, L = 1 and a liquidity provider wants to put x = 0.25 tokens of X and y = 1 tokens of Y.

In this case, the new reserves for the pool will be xₚ = 0.75, yₚ = 3 and L² = xₚ · yₚ = 2.25, so L = 1.5 and liquidity provider receives ΔL = 0.5 liquidity in the form of Uni V2 lp tokens. Now on each trade, a liquidity provider will receive ΔL / L = 1 / 3 share of fees.

In this example we purposefully used x = 0.25 and y = 1 as liquidity provider’s investment so that y / x = 4 = p.

What happens if y / x ≠ p? In this case, some of the tokens Δx or Δy are returned to the liquidity provider so that the leftover ratio (y-Δy)/ x = p or y / (x-Δx) = p. If the liquidity provider wants to utilize their tokens to the full and receive max liquidity, they first must trade their tokens so that y / x = p and then put them into the pool.

For Uni v2, it’s quite straightforward to align your token portfolio to get the maximum liquidity. What about Uni v3? It turns out things are getting way more complex there.

Uniswap v3: single position

In May 2021 Uniswap team launched v3. On Uni v3, you can put liquidity on any price interval [pᵃ, pᵇ]. As long as the price is in the range [pᵃ, pᵇ], you have liquidity L and earn fees. When the price is out of range, you don’t earn any fees until the price is back in the range.

Let’s see how it works in action. First, let’s consider the pool with only one open position with the price interval [pᵃ, pᵇ] = [0.25, 4]. Current pool reserves are xₚ = yₚ = 0.5, the price is p = 1. In this case, as swaps are happening and the price is moving, we observe the following pool behavior:

Here the green curve is the actual token reserves that are used for swaps (real liquidity curve), and the red curve is a virtual liquidity curve emulating as if a user is swapping on Uni v2.

As long as the price is in the range [0.25, 4], the pool behavior is exactly the same as if the pool was UniV2 with a red liquidity curve. When the price is out of bounds, virtual liquidity drops to zero, real liquidity concentrates either in X or in Y token and is not used for swaps.

Uniswap v3: multiple positions

Let’s see now what happens if there are 2 liquidity investments x₁, y₁ on [pᵃ₁, pᵇ₁] and x₂, y₂ on [pᵃ₂, pᵇ₂]. Each of these investments implies (we’ll see how in the following chapters) virtual liquidities L₁ and L₂:

As can be seen, when both intervals cover the price, both real reserves are used, and pool virtual liquidity equals the sum of liquidities. When only one interval covers the price — only its liquidity is used. When the price is out of both intervals, the pool liquidity is zero (or you don’t earn any fees).

This gives Uni v3 a unique feature — a piecewise liquidity function. As the price moves along the virtual curve, the liquidity value changes by some ΔL at certain price points (that are bounds of liquidity positions). You can see such jumps happening at prices pᵃ₁ and pᵇ₁ in Figure 3.

Ticks and tick spacing

The actual life of Uniswap v3 is a bit harder than shown in the figures above. In real Uni v3, you cannot put your liquidity on an arbitrary price interval. Instead, there are so-called ticks that form a discrete grid over the price range. Ticks are defined by the formula (i is an integer):

For each pool, there’s also a notion of tick spacing. Tick spacing is yet another grid on top of ticks that limits the ticks in which you can put liquidity. E.g., for 0.3%-fee pool tick spacing is 60 so that you can put liquidity only in each 60ᵗʰ tick, e.g., 0, -60, 60, 120, -120, … The figure below shows tick spacing ticks (orange) and ticks (black)

Because your liquidity price interval bounds can only be the tick spacing ticks, the liquidity inside any space tick interval is constant and can only change when the price crosses the tick spacing tick.

So we have a piecewise liquidity function with possible jumps happening at tick spacing ticks (similar to Figure 2).

Liquidity value for a position

Let’s see how liquidity L is calculated, given initial tokens x and y, price interval [pᵃ, pᵇ], and current price p.

As you can see from these equations, if the x and y tokens are not in the right proportion (Lx≠Ly), some tokens are returned to the liquidity provider. This is similar to the behavior we observed in Uni v2.

But for Uni v3, it’s more complex since we have the piecewise liquidity function with jumps at tick spacing ticks. In the following chapter, we’ll show how to put tokens in the most effective way on Uni v3.

Effective liquidity providing

If we have a portfolio of x tokens of X and y tokens of Y and we want to provide liquidity to price range [pᵃ, pᵇ] how many tokens X or Y should we swap to get the maximum liquidity out of it?

To answer this question, let’s denote R = y / x — the ratio of tokens in our portfolio and rᵃᵇ(p) — the optimal token ratio such that Lx = Ly. From the formulas for Lx and Ly we can derive:

So our goal is to make R = rᵃᵇ.

However, the task is a bit more complex than just aligning x and y to the specified ratio rᵃᵇ. As we start swapping x for y or vice versa, the pool price p starts changing and so does rᵃᵇ. This behavior is shown in the figure below:

Yet another layer of complexity is as the price p is changing and crossing a tick spacing tick pool liquidity L is changing as well! To solve this problem, let’s first understand how the ratio R evolves as we swap token Y for token X given the liquidity L is constant.

From the equations L²=xy and p = y / x it’s easy to derive:

So if we make a swap of Y for X, subtract fees from Y and the price after swap settles at p₁ (p₁ > p₀):

If the direction is X for Y then p₁ < p₀ and we have:

The next question is:

At what ratio R does the pool price cross the tick and liquidity changes?

If we denote R+ as the ratio at which the upper tick is crossed and R- the ratio for the lower tick, p₀ is the initial price and p-, p+ are respective prices at ticks, L — current liquidity at the tick spacing interval, then we have:

Finally, we are ready to solve the problem.

First, we need to answer 2 questions:

1. Is R > rᵃᵇ(p₀)? If yes, we need to swap Y for X, otherwise — X for Y.
2. As we swap — will the pool price ever cross a tick spacing tick? If no — we can solve the problem right away. If yes — we need to adjust our values as if we swapped all the way to the tick and then repeat our algorithm on the new tick with the new liquidity.

The answers to these questions bring us to 4 different cases:

1. Swapping Y for X inside one tick interval: R > rᵃᵇ(p₀), R+ ≤ rᵃᵇ(p+)
2. Swapping X for Y inside one tick interval: R < rᵃᵇ(p₀), R- ≥ rᵃᵇ(p-)
3. Swapping Y for X in different tick intervals: R > rᵃᵇ(p₀), R+ > rᵃᵇ(p+)
4. Swapping X for Y in different tick intervals: R < rᵃᵇ(p₀), R- < rᵃᵇ(p-)

Case 1: Swapping Y for X inside one tick interval: R > rᵃᵇ(p₀), R+ ≤ rᵃᵇ(p+)

If we swap y for x and the price after the swap settles at p₁ all we need is to make sure Ryx(p₁) = rᵃᵇ(p₁):

If we assume z = √p₁ and rearrange the terms of the equation we’ll get a quadratic equation:

Thus we can solve it and find p₁:

And the amount of token Y to swap is:

Case 2: Swapping X for Y inside one tick interval: R < rᵃᵇ(p₀), R- ≥ rᵃᵇ(p-)

This case is very similar to case 1, except we swap X for Y and thus we need to make sure Rxy(p₁) = rᵃᵇ(p₁):

Similarly to case 1, we can find:

And the amount of token X to swap is:

Case 3: Swapping Y for X in different tick intervals: R > rᵃᵇ(p₀), R+ > rᵃᵇ(p+)

In this case, we swap Y for X until R = R+ and so p = p+ and we’re in the new tick interval with the new liquidity. We remember how many tokens of Y we swapped to add them to the final numbers later. Then we start the algorithm all over and repeat until we hit case 1. That is we redefine:

Case 4: Swapping X for Y in different tick intervals: R < rᵃᵇ(p₀), R- < rᵃᵇ(p-)

Exactly similar to case 3 except we swap X for Y until R = R- and repeat until we hit case 2. We redefine:

Conclusion

Supplying liquidity in the right proportion in Uni v3 is a very complex task. You need to consider a lot of factors like different liquidity values inside tick intervals. The algorithm above describes how you can use the pool data to calculate the number of tokens you need to swap to get the highest liquidity.

The charts for figures are available here:

https://www.desmos.com/calculator/rqbrnapxbj

https://www.desmos.com/calculator/ys7kcfgjxe

https://www.desmos.com/calculator/ehdwkbtu7z

https://www.desmos.com/calculator/huzzwffze9

https://www.desmos.com/calculator/t9u9x8xgcy

In future articles, we plan to discuss other interesting aspects of Uni v3 like impermanent loss, multiposition portfolios, strategy risks, etc.

Who we are

Mellow Protocol is exploring the space of LP-ing and market-making on AMMs. You can also check our initial research paper here. The goal of Mellow is to build a robust ecosystem of tools for eliminating market inefficiencies and generating outcome for users.

We don’t see this just as a product, but as an evolution of what complex math can bring to the DeFi space. Similar to how Uniswap and Curve innovated user trading experience, we believe LP optimization is also pushing forward the boundaries of what was possible in tradfi.

In the next articles, we’re going to discuss more ideas on how to implement proper rebalancing strategies and will move forward to broader topics in DeFi.

Stay tuned!

Follow Mellow on Twitter to be in the loop with our research, and join the discussion in Discord.

Twitter | Discord | Website