About Arrakis Documentation

Welcome to the Arrakis documentation.

Whether you are a developer, liquidity provider, treasury manager, DeFi enjoyooor or an MEV enthusiast, we aim to make this reference guide useful and interesting.

The documentation is structured into three main sections:

• Intro to Arrakis
• Developer Docs
• Resources

Intro to Arrakis is a non-technical tl;dr of the problem we are solving, the Arrakis infrastructure, integrations and user-facing products.

Developer Docs covers smart contract architecture, how to get started guides, an extensive technical reference and more. It also includes module integrations such as HOT AMM. It is aimed at developers interested in understanding the inner workings of Arrakis who are already familiar with Ethereum and the DeFi ecosystem.

Resources contains links to smart contract audits, our research and legacy documentation for Arrakis v1 & v2.

The liquidity must flow.

Overview

Arrakis is an MEV-aware market maker that powers onchain liquidity for token issuers and LPs.

This introduction section provides an overview of Arrakis including:

• History: Arrakis's journey from inception to present day.
• Problem Statement: Centralised actors extracting value from DeFi at the expense of token issuers and LPs.
• Arrakis Infrastructure: The smart contract framework (Arrakis Modular) and offchain market making components.
• Integrations: An overview of integrations on Arrakis Modular like HOT AMM and the upcoming Uniswap v4 Hook.
• Arrakis Pro: The flagship user-facing product for token issuers (protocols and DAOs).

History

Background

Arrakis Finance started in early 2021, shortly after the Uniswap v3 whitepaper was released. The introduction of concentrated Liquidity AMMs promised to finally disrupt the need for traditional Centralized Exchanges (CEX) in terms of efficiency, enabling AMMs to behave similar to their Central Limit Order Book (CLOB) counterparts.

These substantial efficiency improvements over older constant product AMMs unfortunately came at the cost of Liquidity Providers (LPs) facing substantial complexity and overhead associated with trying to fully leverage the potential of providing liquidity in a concentrated fashion on Uniswap V3.

The project, first being part of Gelato Network, later spun out into an independant project after receiving substantial organic traction and going on to have $1.8B TVL.

Arrakis has gone on to facilitate $20B in volume traded.

Since mid 2023, Arrakis has been focussed on the next generation of AMMs and MEV recapture to tackle the biggest threat Ethereum faces: extractive centralised actors.

Centralised Actors Taking Over DeFi

We are in the midst of a shift in DeFi. As Ethereum has grown, sophisticated actors have infiltrated DeFi and leveraged complex strategies to extract value from the ecosystem.

Naturally this has increased the scope of the problem statement Arrakis is tackling. It has grown to encompass recapturing MEV from centralised actors who are extractive to the ecosystem. Arrakis aims to give token issuers and LPs a fairer share of the pie.

Arrakis is focused on being a decentralized onchain market making solution, with a key feature of built-in MEV-Awareness / vertical integration into the MEV supply chain. Arrakis aims to give all token markets a seamless next-generation onchain spot market liquidity provision experience.

Inspiration

The name Arrakis comes in reference to Frank Herbert’s Dune Universe. Arrakis is a harsh desert planet full of dangers and mineable riches (the fabled “spice melange”), which echoes the similarly harsh, dangerous and yet financially potent world of crypto.

Problem Statement

As Ethereum has grown, sophisticated actors have infiltrated DeFi using complex strategies and sophisiticated offchain infrastructure to extract value from Ethereum.

Centralised Vertically-integrated Market Makers (CVMMs) Taking Over DeFi

We define CVMMs as sophisticated centralised actors who simultaneously participate in block building, MEV extraction, private order flow and most recently, capturing volumes via private market makers (PMMs). In other words, trading firms like Wintermute.

CVMMs extract the majority of profits from onchain liquidity, leaving protocols and liquidity providers to fight for toxic order flow. As of Oct 2024, Token Issuers, Retail DeFi, and other LPs have leaked $800M in MEV to poorly designed AMMs since the merge (Oct 2022).

Before Intent protocols like UniswapX, CoWSwap and 1inch Fusion emerged, CVMMs primarily focused on extracting value from passive LPs and onchain traders by channeling MEV and arbitrage strategies through their own block builders.

The Rise of Intents Protocols

UniswapX, CoWSwap and 1inch Fusion account for more than 50% of all trades on Ethereum, as of October 2024 (link). As intents have gained pace, these actors have started to monopolize DeFi, leaving LPs with less revenue and more exposure to toxic flow.

Intents Protocols have disrupted the onchain trading landscape. While they might offer swappers better pricing in the short-term, they exacerbate losses for passive LPs who are now left behind with less healthy flow from noise trading and a higher relative quantity of toxic, arbitrage-laden order flow. How so? Intent protocols offer CVMMs the ability to fill non-toxic order flow on their own private inventory via proprietary and highly sophisticated RFQ systems, which passive LPs cannot compete with.

But even swappers will be hurt in the long-term. As highlighted in the excellent paper titled Illuminating Ethereum's Order FLow Landscape by the Flashbots team:

• Order from retail users is being segmentation away from passive LPs to a permissioned set of market makers
• This in turn drives power to the hands of a few actor, creating a winner-takes-all dynamic
• Ove the long-term, even swappers will be hurt as powerful actors dictate liquidity provision.

In short, the designs of intents could even threaten the very decentralised nature of Ethereum by giving power to a few powerful actors. We shouldn't repeat the same mistakes from TradFi where extractive market makers take the lions share of profits.

Long Tail Liquidity

Furthermore, CVMMs are poorly equipped to cater to longtail assets, which will become a bigger problem as more of the world’s value moves onchain.

CVMMs cannot service the entire long tail of tokens since they lack the inventory and operational scale. This results in the long-tail market being underserved, not benefiting from the improved pricing and capital efficiency that PMMs have provided to blue chips. The vast majority of these tokens are highly illiquid and mostly operate on legacy DEX infrastructure.

Where Arrakis Fits in

Arrakis is focused on being a decentralized onchain market making solution, with a key feature of built-in MEV-Awareness / vertical integration into the MEV supply chain. By recapturing value to the application layer, Arrakis protects token issuers and LPs capital and increases their profitability.

Arrakis is building the first decentralised vertically-integrated market making solution.

Arrakis Infrastructure

Arrakis Infrastructure consists of two components:

• Offchain Market Making
• Smart Contract Framework

Together the Arrakis offchain market making and the Arrakis Modular (smart contract framework) form the Arrakis infrastructure known as the Arrakis protocol.

For example, HOT AMM is formed by the following components:

• Arrakis Quoter and other offchain market making components.
• Arrakis Modular (smart contract framework) using public vaults.
• Valantis Modular DEX framework (as the 1st integration).

Offchain Market Making

Arrakis Offchain Market Making is a suite of tools that allow Arrakis to make markets onchain.

They are comprised of:

• Arrakis Rebalancer
• Arrakis Quoter
• Arrakis Liquidity Concentrator
• Arrakis Swapper
• Arrakis Alerting System

Smart Contract Framework (Arrakis Modular)

Arrakis Modular represents the next evolution of the Arrakis onchain liquidity management smart contracts. Arrakis Modular introduces a universal Meta-Vault standard, which standardizes the interface for integration any two-sided liquidity provision protocol. Arrakis Modular is highly flexible, reusable and scalable:

• Flexibility: Modules adhering to a common interface can be easily developed and attached, supporting a broad range of DEXs and use-cases.
• Reusability: The Arrakis Vault standard facilitates the reuse of components and maintenance of standard interfaces, streamlining future expansions.
• Scalability: Adapting to new liquidity pool types becomes straightforward, focusing on module development rather than protocol overhauls.

Dive into the technical details in the developers documentation section at Arrakis Modular.

Vault Integrations

Arrakis is focused on being a decentralized onchain market making solution, with a key feature of built-in MEV-Awareness / vertical integration into the MEV supply chain. Arrakis aims to give all token markets a seamless next-generation onchain spot market liquidity provision experience.

Here you can find more information on the integrations available on Arrakis Modular:

1. HOT AMM: HOT improves returns and maximizes capital efficiency for LPs, by internalizing MEV using an intent-based design. Designed in partnership with Valantis Labs, built on the Valantis Modular DEX Framework. It is the first integration on Arrakis Modular and is powered by Arrakis's offchain market making infrastructure.

2. Uniswap v4 Hook: Coming soon...

More on Arrakis Modular

The potential for integrations extends beyond single DEXs. While current use cases focus on modules which each integrate an individual DEX liquidity provision protocol, in theory, modules could become more complex, enabling integrations with multiple DEXs simultaneously or combining DEX and peripheral protocols like lending markets or options protocols for advanced functionality (hedging and delta-neutral strategies etc). The architecture of Arrakis Modular supports such future innovations.

HOT AMM

LPs are getting rekt by toxic order flow. HOT improves returns and maximizes capital efficiency for LPs, by internalizing MEV using an intent-based design.

HOT is a first of its kind hybrid AMM design, that combines the permissionless properties of AMMs with the capital efficiency and non-toxic order flow of intents protocols.

Problem Statement

LPs bear the high cost of rebalancing AMMs

By design, AMMs 'pay' arbitrageurs to rebalance pools. In the 2022 paper Automated Market Making and Loss-Versus-Rebalancing, Columbia University professor and a16z researcher Tim Roughgarden and his team found that arbitrage costs ETH-USDC LPs about 11% of their principal per year.

The rise of intents protocols has spawned a new class of centralised actors

An unintended consequence of intents protocols is that they have birthed a new class of liquidity provider called the "Centralised Vertically-integrated Market Maker" (CVMM).

Good flow to centralised actors and toxic order flow to AMMs

The sophisticated offchain infrastructure of CVMMs gives them an unfair advantage over passive LPs. LPs are left to compete for toxic order flow, driving passive LPs close to extinction.

How HOT AMM works

HOT was designed by Arrakis and Valantis Labs. It is built on the Valantis Modular DEX Framework. HOT is the first integration on Arrakis Modular and is powered by Arrakis's offchain market making infrastructure.

HOT pools have two swap execution mechanisms:

RfQ Quotes

• Solvers compete for non-toxic uninformed order flow from intents protocols like CoW Swap, Uniswap X and 1inch Fusion.
• In turn these solvers update the pool price.

Permissionless AMM

• Anyone can swap against the AMM which is akin to Uniswap v3. In addition a dynamic fee is implemented.
• A dynamic fee that increases over time is used to further protect the pool against stale price arbitrage, in the event that a RfQ Quotes hasn’t been issued onchain recently. This fee is reset at the time a RfQ signed quoted is executed onchain.

To learn more, refer to the HOT AMM section.

Uniswap v4 Hook

Coming soon...

Arrakis Pro: Liquidity Management for Token Issuers

Arrakis Pro is the industry leading, non-custodial onchain liquidity management solution for token issuers (protocols and DAOs). Arrakis Pro powers protocol owned liquidity.

Problem Statement

Uniswap v3 introduced the concept of concentrated liquidity AMM pools which enabled high capital efficiency, but were complex to manage.

Arrakis Pro supports token issuers by:

• Supporting token launches
• Bootstraping liquidity
• Ongoing inventory management

Benefits

Protocols and DAOs can benefit from the following:

1. Greater capital efficiency: narrow price range with rebalancing to keep the price in the range.
2. Minimum price impact: increased liquidity depth leading to reduced downside price impact and market volatility.
3. Return on capital: facilitate more trading volumes whilst reducing toxic order flow.
4. Active inventory management: exposure the right amount of liquidity at the right time.

Solution

Arrakis Pro simplifies the process of managing concentrated liquidity by automating liquidity provisioning and rebalancing, for any concentrated liquidity pool (including Uniswap v3, HOT AMM and Uniswap v4). Arrakis Pro is powered by Arrakis's Offchain Market Making infrastructure.

Arrakis Pro was formerly known as PALM (built on top of Uniswap v3). With Arrakis Modular — the new and improved version of the Arrakis vaults — any DEX can be supported.

Get in Touch

Arrakis Pro is trusted by Maker, EtherFi, Across, Lido, Stargate, Gnosis, Angle, Mountain, Kwenta, Index, Sturdy, Everclear and many more leading protocols. As of October 2024, Arrakis vaults have facilitated over $20B in transactions.

Contact us to learn more about how Arrakis Pro can support your token launch and ongoing liquidity management.

Overview

Arrakis Modular represents the next evolution of the Arrakis onchain liquidity management protocol, aiming to overcome the limitations of previous versions (V1 and V2). Across versions, Arrakis vaults allow Liquidity Providers (LPs) to Decentralized Exchanges (DEXs) actively manage or delegate the management of their liquidity positions. However, Arrakis V1 and V2 were specifically built around Uniswap V3. Therefore, the previous standards were incompatible with other DEXs, and in order to support alternative venues (e.g. Uniswap V4, Balancer, Ambient, etc) Arrakis would have to make a completely new standard for every integration.

To address this, Arrakis Modular introduces a universal Meta-Vault standard. This modular framework enables the attachment of standardized modules to any two-sided liquidity provision protocol, simplifying the integration process. Key features include:

• Flexibility: Modules adhering to a common interface can be easily developed and attached, supporting a broad range of DEXs and use-cases.
• Reusability: The Arrakis Vault standard facilitates the reuse of components and maintenance of standard interfaces, streamlining future expansions.
• Scalability: Adapting to new liquidity pool types becomes straightforward, focusing on module development rather than protocol overhauls.

With Arrakis Modular essentially any onchain DeFi strategy based on a dual-asset underlying can be created and tokenized, simply by developing the corresponding module which correctly adheres to the Arrakis Meta-Vault module interface

We envision Arrakis Modular not only as a technical advancement internally, but as a platform for community and developer collaboration, inviting contributions to the ecosystem. With this modular approach, Arrakis Finance is poised to rapidly adapt to the evolving DeFi landscape, unlocking new possibilities for liquidity management.

Finally, note that the potential for modules extends beyond single DEX integrations. While current use cases focus on modules which each integrate an individual DEX liquidity provision protocol, in theory, modules could become more complex, enabling integrations with multiple DEXs simultaneously or combining DEX and peripheral protocols like lending markets or options protocols for advanced functionality (hedging and delta-neutral strategies etc). The architecture of Arrakis Modular supports such future innovations.

Architecture

At the heart of the Arrakis Modular system is the concept of Meta Vaults. These Meta Vaults enable users wishing to provide liquidity with two distinct assets to do so across any trading venue—without the need to deploy or migrate funds to new vaults. Meta Vaults have the capability to whitelist various modules, essentially smart contracts that establish integration with liquidity-consuming dApps. This design ensures that as new DEXs emerge, liquidity provision becomes a matter of simply creating and whitelisting a new module compatible with the DEX, and then activating it.

For now, the domain of use-cases considered for a module could still all be integrations with a (single) DEX liquidity provision protocol, though technically modules could become more complex (a module that integrates with multiple DEXs simultaneously and can rebalance across them, or a module that integrates a DEX and peripheral protocols like lending markets or options protocols).

Arrakis Meta Vault

Meta Vaults are a core component of the Arrakis Modular system, designed to provide a flexible and efficient way for users to manage liquidity across various decentralized exchanges (DEXs) and trading venues. The key features and concepts of Meta Vaults include:

1. Versatile Liquidity Provision: Meta Vaults allow users to provide liquidity using two distinct assets across multiple trading platforms without the need to deploy or migrate funds to separate vaults for each platform.

2. Modular Architecture: The system uses a modular approach, where modules (smart contracts) can be whitelisted to integrate with different liquidity-consuming decentralized applications (dApps). This modularity allows for easy expansion to new DEXs by simply creating and whitelisting new compatible modules.

3. Two Types of Meta Vaults:

   

   a. Public Meta Vaults: These are ERC20-wrapped vaults intended for shared liquidity positions or strategies. They allow for delegated management of liquidity on behalf of multiple participants.

   

   b. Private Meta Vaults: These are designed for token issuers and individual users to manage or delegate management of their own private liquidity. The ownership and transfer rights of Private Meta Vaults can be tokenized as a fully onchain NFT, as shown below.

   

4. Factory: It is responsible for deploying new instances of both public and private Meta Vaults. It maintains a list of all deployed vaults and manages permissions for public vault deployments.

This architecture allows for efficient liquidity management across multiple platforms while providing options for both shared and private liquidity strategies, all within a modular and extensible framework.

Modules

Modules are smart contracts that act as a bridge between Meta Vaults and specific decentralized exchanges (DEXs) or liquidity protocols. They encapsulate the logic for interacting with particular trading venues, allowing Meta Vaults to provide liquidity across various platforms without changing their core structure.

These modules are whitelisted through public and private registry contracts to ensure security and proper functionality. While currently focused on single DEX integrations, the modular design allows for potential expansion into more complex scenarios, such as multi-DEX interactions or integration with other DeFi protocols.

The key strength of modules lies in their flexibility and standardization. As new DEXs emerge or trading strategies evolve, new modules can be created and integrated seamlessly, enabling the Arrakis system to adapt to the rapidly changing DeFi landscape.

You can explore some module implementations built by Arrakis here.

Admin and Security

Arrakis Modular employs a multi-layered security approach that combines proactive management, rapid response capabilities, and enforced delays on critical changes. The three core elements are the following:

1. Arrakis Standard Manager: serves as the entry point for active management of both private and public vaults. It implements additional safety checks to ensure delegated LP management is secure and trustless. It also handles the configuration and collection of management fees.

2. Guardian: responsible for implementing a rushing pauser role that can quickly pause parts of the system in case of critical errors or vulnerabilities.

3. TimeLock: enforces a delay on changes to critical security parameters. This provides security guarantees for public Meta Vaults against compromised multisigs and malicious actors.

Routers

Arrakis Routers serve as crucial intermediaries that enhance security, improve user experience, and optimize gas usage. By providing a standardized entry point, routers can implement additional safety checks, simplify complex multi-step processes into single transactions, and enable gas-efficient operations through batching. Some of the implementations are the following:

• Public Meta Vault Router: streamlines the process of adding liquidity to ArrakisMetaVaultPublic instances. It integrates Permit2, a standardized token approval system, which enhances both security and user experience.
• Swap Executor: is a sub-component of the Public Meta Vault Router. Its primary role is to execute token swaps in a secure manner. This middleman contract is necessary to mitigate potential security risks associated with low-level, generic swap operations.

Guides

The following guides are intended for users and developers that wish to interact with Arrakis Modular directly at the smart contract level. They also serve as a comprehensive walkthrough for users curious about the implementation details of core elements of the protocol. The guides are composed by

• Quickstart: here we dive deep into the details behind the experience behind our UI, specifically we explain the addLiquidity and removeLiquidity flows.

Quickstart

In this guide we provide all the elements to participate in a Public Vault, built on top of Arrakis Modular. We explain how to use the Public Router to deposit and remove funds from a Public Vault.

• Introduction
• Add Liquidity
• Remove Liquidity

Introduction

Public Vault Depositor

Depositors supply two-sided liquidity in the current asset ratio of the Public Vault, minting an ERC20 LP receipt token. The vault's LP receipt token represents a claim on a proportion of the underlying vault assets which are being supplied to a DEX liquidity pool under the hood. LP tokens have a claim on a fluctuating amount of the two deposited assets, since swappers trade against the tokens in the liquidity pool (given the rules and constraints of the pool). LP token holders can burn these tokens at any time, to execute the claim and receive back the corresponding share of the vault's underlying two tokens at that time.

The beauty of Arrakis Modular Public Vaults is that the specific complexities of a DEX (its interfaces, LP decision space, and quirks) are abstracted away from depositors and every Arrakis Modular Public Vault has a simple UniswapV2-style experience, where LPs only make decisions about when and how much liquidity to provide, and when and how much liquidity to withdraw. The rest is a black box to an uncurious depositor who does not need to know how the liquidity is actively managed or even what DEX the liquidity is being supplied to. They can simple track the value and asset composition of their LP token at every block and decide if they are happy with the returns of the portfolio.

Public Vault Owner

In Arrakis Modular, Public Vaults can only be created by whitelisted and thus trusted parties. The whitelisted vault creator initializes a new vault with its asset pair, initial module, initial management configuration, and a timelocked owner role who has sensitive powers to set and reset vault whitelisted module(s) and vault management configuration. For every Public Vault created, a corresponding Timelock contract is also deployed which immutably controls ownership functions. The transferrable owner role is set on this Timelock contract. Thus, a Public Vault owner has the power to adjust important and sensitive Vault parameters but these changes are guaranteed to be behind (at least) a 48 hour timelock.

This gives Public Vault depositors some time to react to vault parameter updates even in the worst case scenario (e.g. malicious Public Vault owner activity). In the future the whitelisted Public Vault creator role and timelocked Public Vault Owner role set on creation, would both be in the hands of the Arrakis DAO and controlled with onchain governance. As of today (15/10/2024) these roles are controlled by an Arrakis Multisig requiring 4 signatures.

Add Liquidity

As we explained in the previous section, depositors who wish to provide liquidity to a Public Meta Vault must do it with both tokens in the pool and in the current proportion of the reserves. To simplify this process and improve the user experience we have designed a Public Router. This contract is in charge of getting the right amounts and tokens to deposit. This is achieved by integrating with a swap aggregator and wrapping tokens when necessary. It also implements the Permit 2 standard for gassless approvals.

The following guide provides a step-by-step explanation of adding liquidity by uisng our router.

1. Identify the Meta Vault associated to the pair you want to participate in. See for example here for a full list of deployment addresses related to HOT AMM.

2. From now on, we use the Arrakis Public Router contract, defined here ArrakisPublicVaultRouter.sol

3. Next step is to determine how many of each tokens are needed to join the Meta Vault. There are several options:

   • Use getMintAmounts to determine the extact amounts of token0 and token1 to deposit.
   • If you own only one of the tokens, you can either swap on your own to match the amounts needed, or you can use the buil-in swap features in ArrakisPublicVaultRouter. In the latter, only one token needs to be authorized.

4. In order to set token transfer authorizations before depositing, there are two alternatives:

   • Calling the standard ERC20 Approve
   • Set up Permit2 data and signature

5. Now, in order to deposit into the pool there are multiple paths:

   • If you set up ERC20 approvals:

     • Call addLiquidity to deposit both tokens to the vault.
     • If you have ETH and want to deposit into a pool with WETH as one of its tokens, you can also call wrapAndAddLiquidity.
     • If you have only one of the tokens in the pair, you can call swapAndAddLiquidity
     • If you only have ETH and want to deposit into a pool with WETH as one of its tokens, you can call wrapAndSwapAndAddLiquidity

   • If you have set the correct Permit2 data and signature you should respectively call addLiquidityPermit2, wrapAndAddLiquidityPermit2, swapAndAddLiquidityPermit2 or wrapAndSwapAndAddLiquidityPermit2

6. Once your deposit transaction goes through, you obtain ERC20 LP shares of the vault you are depositing to.

Remove Liquidity

Here we explain how to remove liquidity from a Meta Vault that you own LP shares of.

1. Identify the Meta Vault address you want to exit, and verify it matches the address of your LP token. See for example here for a full list of deployment addresses related to HOT AMM.
2. From now on, we use the Arrakis Public Router contract, defined here ArrakisPublicVaultRouter.sol
3. Approve the LP token amount you want to burn and convert in the underlying tokens by using the standard ERC20 Approve. The approval must be to ArrakisPublicVaultRouter. Alternatively, you can set up Permit2 data and signature for a gasless approval transaction.
4. Prepare the RemoveLiquidityData
5. Depending on the approval type for the vault LP token, there are two paths:

• If you did an ERC20 approval, call removeLiquidity.
• If you set up Permit2 Data and Signature, call removeLiquidityPermit2

6. You will receive token0 and token1 amounts correspondig to the amount of shares burned.

Deployments

Arrakis Modular Smart Contracts are deployed on Mainnet, Arbitrum, Base and Sepolia.

* Not available on Sepolia

Technical reference

Getting Started

In order to run the test suite of Arrakis modular smart contracts, follow these steps:

1. Clone the repository by running:

git clone https://github.com/ArrakisFinance/arrakis-modular.git

2. Install the required submodules and compile the contracts by running:

forge build

3. Create .env file using .envExample as a reference. You can fill in your own alchemy api key (or a different RPC url altogether)
4. Execute the test suite by running:

forge test -vv

If tests run and pass then your dev environment is set up correctly!

Arrakis Modular Smart Contracts

Meta-Vaults

Vaults

abstracts/ArrakisMetaVault.sol This contract is the core of the minimal Arrakis Meta Vault standard. It encodes the interfaces and patterns of an Arrakis Meta Vault. A functional ArrakisMetaVault has a module contract connected to it which entirely defines how the vault integrates with an underlying Liquidity Provision protocol, using standard interfaces. This contract is abstract because it is extended to expose the differenced in the Public and Private vault type, most notable how they are tokenized and how the deposit function is implemented.

• ArrakisMetaVaultPublic.sol This inherits and extends the abstract ArrakisMetaVault.sol to create the ERC20 wrapped “public” Arrakis Meta Vault. If we want to create a shared LP position/strategy which can configure or delegate LP active management on behalf of all participants, then we’ll deploy an instance of this through the Factory contract. Public Vault deployments are permissioned since sensitive security parameters for multiple parties are under the timelocked control of a vault owner, so we want some ability to control who might deploy/configure/own these public vaults. Eventually this authority would be under the control of the “Arrakis DAO.”

• ArrakisMetaVaultPrivate.sol This inherits and extends the abstract ArrakisMetaVault.sol to create the “private” Arrakis Meta Vault, where only the vault owner controls adding or removing liquidity. If you want to create an LP management contract for your own private liquidity (we call this PALM for private active liquidity management) you’d deploy an instance of this through the Factory contract. Ownership is not timelocked and deployment is permissionless in this case, since the sensitive security parameters are fundamentally under the control of the custodian of the vault funds (i.e. the owner is the user).

Factory

ArrakisMetaVaultFactory.sol deploys fresh instances of ArrakisMetaVaultPublic and ArrakisMetaVaultPrivate public vault deployments are permissioned, but private vault ones are not. Stores complete list of all vaults deployed, by type.

Ownership

PrivateVaultNFT.sol an NFT contract that allows ownership of private vaults to each be tokenized and thus transferrable. Very standard NFT contract

Modules

abstract/ModuleRegistry.sol this abstract contract handles the simple duty of “module” whitelistsing, so only modules deemed safe and correct can be used by vaults.

• ModulePrivateRegistry.sol registry of all modules which can be whitelisted and used by private vaults.

• ModulePublicRegsitry.sol registry of all modules which can be whitelisted and used by public vaults.

Implementations

modules/ValantisSOTModule.sol This is the first ArrakisMetaVault module we will put into production, integrating a specific Sovereign Pool type of the new Valantis DEX.

Administration

ArrakisStandardManager.sol The manager contract that adds additional safety checks to make delegated LP management safe and as trustless as possible. Arrakis will use this as the entry point to actively manage both private vaults and public vaults. Also how we confiuge/harvest manager fee collection for Arrakis protocol to take cut of revenues generated.

Security

Guardian.sol this contract is in charge of a rushing pauser role who can pause parts of the system in the case of critical error/vulnerability. This authority would be ultimately in the hands of some “Guardian Multisig” much like how AAVE works today. For any upgradeable contracts (modules are all beacon proxies and could potentially be upgradeable) there would be a timelock. So pauses are rushing but upgrades are slow.

TimeLock.sol a slightly modified generic timelock (so that timelock cannot transfer ownership of the vault away from the timelock contract) a fresh instance of this is used for each Public Arrakis vault to make sure that security parameters cannot be rushingly reconfigured by a compromised public vault owner to extract value from the public vault.

Routing

ArrakisPublicVaultRouter.sol A router contract which integrates permit2 which helps depositors add liquidity to ArrakisMetaVaultPublic instances, safely and conveniently.

RouterSwapExecutor.sol a sub-component of the Public Vault Router used for swapping safely (need the middleman contract here for security concerns on these generic low level swaps being abused)

Meta Vaults

Content

• Core
• Public Vaults
• Private Vaults

Core

Content

• Arrakis Meta Vault
• Arrakis Meta Vault Factory

ArrakisMetaVault

Git Source

Inherits: IArrakisMetaVault, ReentrancyGuard, Initializable

State Variables

moduleRegistry

address public immutable moduleRegistry;

token0

address public immutable token0;

token1

address public immutable token1;

manager

address public immutable manager;

module

IArrakisLPModule public module;

_whitelistedModules

EnumerableSet.AddressSet internal _whitelistedModules;

Functions

onlyOwnerCustom

modifier onlyOwnerCustom();

onlyManager

modifier onlyManager();

constructor

constructor(
    address moduleRegistry_,
    address manager_,
    address token0_,
    address token1_
);

initialize

function initialize(address module_) external initializer;

setModule

function used to set module

function setModule(
    address module_,
    bytes[] calldata payloads_
) external onlyManager nonReentrant;

Parameters

whitelistModules

function used to whitelist modules that can used by manager.

we transfer here all tokens to the new module.

function whitelistModules(
    address[] calldata beacons_,
    bytes[] calldata data_
) external onlyOwnerCustom;

Parameters

blacklistModules

function used to blacklist modules that can used by manager.

function blacklistModules(address[] calldata modules_)
    external
    onlyOwnerCustom;

Parameters

whitelistedModules

function used to get the list of modules whitelisted.

function whitelistedModules()
    external
    view
    returns (address[] memory modules);

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying()
    public
    view
    returns (uint256 amount0, uint256 amount1);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96_)
    external
    view
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

_withdraw

function _withdraw(
    address receiver_,
    uint256 proportion_
) internal returns (uint256 amount0, uint256 amount1);

_withdrawManagerBalance

function _withdrawManagerBalance(IArrakisLPModule module_)
    internal
    returns (uint256 amount0, uint256 amount1);

_call

function _call(address module_, bytes memory data_) internal;

_onlyOwnerCheck

function _onlyOwnerCheck() internal view virtual;

ArrakisMetaVaultFactory

Git Source

Inherits: IArrakisMetaVaultFactory, Pausable, Ownable

this contract will use create3 to deploy vaults.

State Variables

moduleRegistryPublic

address public immutable moduleRegistryPublic;

moduleRegistryPrivate

address public immutable moduleRegistryPrivate;

creationCodePublicVault

address public immutable creationCodePublicVault;

creationCodePrivateVault

address public immutable creationCodePrivateVault;

nft

PrivateVaultNFT public immutable nft;

manager

address public manager;

_publicVaults

EnumerableSet.AddressSet internal _publicVaults;

_privateVaults

EnumerableSet.AddressSet internal _privateVaults;

_deployers

EnumerableSet.AddressSet internal _deployers;

Functions

constructor

constructor(
    address owner_,
    address manager_,
    address moduleRegistryPublic_,
    address moduleRegistryPrivate_,
    address creationCodePublicVault_,
    address creationCodePrivateVault_
);

pause

function used to pause the factory.

only callable by owner.

function pause() external onlyOwner;

unpause

function used to unpause the factory.

only callable by owner.

function unpause() external onlyOwner;

setManager

function used to set a new manager.

only callable by owner.

function setManager(address newManager_) external onlyOwner;

Parameters

deployPublicVault

function used to deploy ERC20 token wrapped Arrakis Meta Vault.

function deployPublicVault(
    bytes32 salt_,
    address token0_,
    address token1_,
    address owner_,
    address beacon_,
    bytes calldata moduleCreationPayload_,
    bytes calldata initManagementPayload_
) external whenNotPaused returns (address vault);

Parameters

Returns

deployPrivateVault

function used to deploy owned Arrakis Meta Vault.

function deployPrivateVault(
    bytes32 salt_,
    address token0_,
    address token1_,
    address owner_,
    address beacon_,
    bytes calldata moduleCreationPayload_,
    bytes calldata initManagementPayload_
) external whenNotPaused returns (address vault);

Parameters

Returns

whitelistDeployer

function used to grant the role to deploy to a list of addresses.

function whitelistDeployer(address[] calldata deployers_)
    external
    onlyOwner;

Parameters

blacklistDeployer

function used to grant the role to deploy to a list of addresses.

function blacklistDeployer(address[] calldata deployers_)
    external
    onlyOwner;

Parameters

getTokenName

get Arrakis Modular standard token name for two corresponding tokens.

function getTokenName(
    address token0_,
    address token1_
) public view returns (string memory);

Parameters

Returns

publicVaults

get a list of public vaults created by this factory

function publicVaults(
    uint256 startIndex_,
    uint256 endIndex_
) external view returns (address[] memory);

Parameters

Returns

numOfPublicVaults

numOfPublicVaults counts the total number of public vaults in existence

function numOfPublicVaults() public view returns (uint256 result);

Returns

isPublicVault

isPublicVault check if the inputed vault is a public vault.

function isPublicVault(address vault_) external view returns (bool);

Parameters

Returns

privateVaults

get a list of private vaults created by this factory

function privateVaults(
    uint256 startIndex_,
    uint256 endIndex_
) external view returns (address[] memory);

Parameters

Returns

numOfPrivateVaults

numOfPrivateVaults counts the total number of private vaults in existence

function numOfPrivateVaults() public view returns (uint256 result);

Returns

isPrivateVault

isPrivateVault check if the inputed vault is a private vault.

function isPrivateVault(address vault_)
    external
    view
    returns (bool);

Parameters

Returns

deployers

function used to get a list of address that can deploy public vault.

function deployers() external view returns (address[] memory);

_initManagement

function _initManagement(
    address vault_,
    bytes memory data_
) internal;

_getPublicVaultConstructorPayload

to anticipate futur changes in the manager's initManagement function manager should implement getInitManagementSelector function, so factory can get the the right selector of the function.

for initializing management we need to know the vault address, so manager should follow this pattern where vault address is the first parameter of the function.

function _getPublicVaultConstructorPayload(
    address timeLock_,
    address token0_,
    address token1_
) internal view returns (bytes memory);

_append

function _append(
    string memory a_,
    string memory b_,
    string memory c_,
    string memory d_
) internal pure returns (string memory);

Public Vaults

Content

• Arrakis Meta Vault Public
• Creation Code Public Vault

ArrakisMetaVaultPublic

Git Source

Inherits: IArrakisMetaVaultPublic, ArrakisMetaVault, Ownable, ERC20

State Variables

_name

string internal _name;

_symbol

string internal _symbol;

Functions

constructor

constructor(
    address owner_,
    string memory name_,
    string memory symbol_,
    address moduleRegistry_,
    address manager_,
    address token0_,
    address token1_
) ArrakisMetaVault(moduleRegistry_, manager_, token0_, token1_);

mint

function used to mint share of the vault position

function mint(
    uint256 shares_,
    address receiver_
) external payable returns (uint256 amount0, uint256 amount1);

Parameters

Returns

burn

function used to burn share of the vault position.

function burn(
    uint256 shares_,
    address receiver_
) external returns (uint256 amount0, uint256 amount1);

Parameters

Returns

transferOwnership

override transfer of ownership, to make it not possible.

function transferOwnership(address) public payable override;

renounceOwnership

override transfer of ownership, to make it not possible.

function renounceOwnership() public payable override;

completeOwnershipHandover

override transfer of ownership, to make it not possible.

function completeOwnershipHandover(address) public payable override;

name

function used to get the name of the LP token.

function name() public view override returns (string memory);

Returns

symbol

function used to get the symbol of the LP token.

function symbol() public view override returns (string memory);

Returns

_deposit

function _deposit(uint256 proportion_)
    internal
    nonReentrant
    returns (uint256 amount0, uint256 amount1);

_onlyOwnerCheck

msg.sender should be the tokens provider

function _onlyOwnerCheck() internal view override;

CreationCodePublicVault

Git Source

Inherits: ICreationCode

Functions

getCreationCode

function getCreationCode() external pure returns (bytes memory);

Private Vaults

ArrakisMetaVaultPrivate

Git Source

Inherits: ArrakisMetaVault, IArrakisMetaVaultPrivate, IOwnable

State Variables

nft

address public immutable nft;

_depositors

EnumerableSet.AddressSet internal _depositors;

Functions

constructor

constructor(
    address moduleRegistry_,
    address manager_,
    address token0_,
    address token1_,
    address nft_
) ArrakisMetaVault(moduleRegistry_, manager_, token0_, token1_);

deposit

function used to deposit tokens or expand position inside the inherent strategy.

function deposit(
    uint256 amount0_,
    uint256 amount1_
) external payable;

Parameters

withdraw

function used to withdraw tokens or position contraction of the underpin strategy.

function withdraw(
    uint256 proportion_,
    address receiver_
)
    external
    onlyOwnerCustom
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

whitelistDepositors

function used to whitelist depositors.

function whitelistDepositors(address[] calldata depositors_)
    external
    onlyOwnerCustom;

Parameters

blacklistDepositors

function used to blacklist depositors.

function blacklistDepositors(address[] calldata depositors_)
    external
    onlyOwnerCustom;

Parameters

owner

function used to get the owner of this contract.

function owner() external view returns (address);

depositors

function used to get the list of depositors.

function depositors() external view returns (address[] memory);

Returns

_deposit

function _deposit(
    uint256 amount0_,
    uint256 amount1_
) internal nonReentrant;

_onlyOwnerCheck

msg.sender should be the tokens provider

function _onlyOwnerCheck() internal view override;

CreationCodePrivateVault

Git Source

Inherits: ICreationCode

Functions

getCreationCode

function getCreationCode() external pure returns (bytes memory);

PrivateVaultNFT

Git Source

Inherits: Ownable, ERC721, IPrivateVaultNFT

State Variables

renderController

address public immutable renderController;

Functions

constructor

constructor() ERC721("Arrakis Private LP NFT", "ARRAKIS");

mint

function used to mint nft (representing a vault) and send it.

function mint(address to_, uint256 tokenId_) external onlyOwner;

Parameters

tokenURI

function tokenURI(uint256 tokenId_)
    public
    view
    override
    returns (string memory);

getMetaDatas

function getMetaDatas(
    address token0_,
    address token1_
)
    public
    view
    returns (
        uint8 decimals0,
        uint8 decimals1,
        string memory symbol0,
        string memory symbol1
    );

RenderController

Git Source

Inherits: Ownable, IRenderController, Initializable

State Variables

renderer

address public renderer;

Functions

initialize

function initialize(address owner_) external initializer;

setRenderer

function used to set the renderer contract

only the svgController can do it.

function setRenderer(address renderer_) external onlyOwner;

Parameters

isNFTSVG

function isNFTSVG(address renderer_) public view returns (bool);

Modules

Content

• Registry
• Implementations

Registry

Content

• Module Registry
• Module Public Registry
• Module Private Registry

ModuleRegistry

Git Source

Inherits: IModuleRegistry, Ownable, Initializable

State Variables

factory

IArrakisMetaVaultFactory public factory;

admin

should be a timelock contract.

address public immutable admin;

_guardian

address internal immutable _guardian;

_beacons

EnumerableSet.AddressSet internal _beacons;

Functions

constructor

constructor(address owner_, address guardian_, address admin_);

initialize

function used to initialize module registry.

function initialize(address factory_) external initializer;

Parameters

beacons

function to get the whitelisted list of IBeacon that have module as implementation.

function beacons() external view returns (address[] memory);

Returns

beaconsContains

function to know if the beacons enumerableSet contain beacon_

function beaconsContains(address beacon_)
    external
    view
    returns (bool isContained);

Parameters

guardian

function used to get the guardian address of arrakis protocol.

function guardian() external view returns (address);

Returns

whitelistBeacons

function used to whitelist IBeacon that contain implementation of valid module.

function whitelistBeacons(address[] calldata beacons_)
    external
    onlyOwner;

Parameters

blacklistBeacons

function used to blacklist IBeacon that contain implementation of unvalid (from now) module.

function blacklistBeacons(address[] calldata beacons_)
    external
    onlyOwner;

Parameters

_createModule

function _createModule(
    address vault_,
    address beacon_,
    bytes calldata payload_
) internal returns (address module);

_checkVaultNotAddressZero

function _checkVaultNotAddressZero(address vault_) internal pure;

ModulePublicRegistry

Git Source

Inherits: ModuleRegistry, IModulePublicRegistry

Functions

constructor

constructor(
    address owner_,
    address guardian_,
    address admin_
) ModuleRegistry(owner_, guardian_, admin_);

createModule

function used to create module instance that can be whitelisted as module inside a vault.

function createModule(
    address vault_,
    address beacon_,
    bytes calldata payload_
) external returns (address module);

Parameters

ModulePrivateRegistry

Git Source

Inherits: ModuleRegistry, IModulePrivateRegistry

Functions

constructor

constructor(
    address owner_,
    address guardian_,
    address admin_
) ModuleRegistry(owner_, guardian_, admin_);

createModule

function used to create module instance that can be whitelisted as module inside a vault.

function createModule(
    address vault_,
    address beacon_,
    bytes calldata payload_
) external returns (address module);

Parameters

Implementations

Content

• Valantis Module

ValantisModule

Git Source

Inherits: IArrakisLPModule, IValantisHOTModule, PausableUpgradeable, ReentrancyGuardUpgradeable

BeaconProxy be careful for changing implementation with upgrade.

State Variables

metaVault

IArrakisMetaVault public metaVault;

pool

ISovereignPool public pool;

alm

IHOT public alm;

token0

IERC20Metadata public token0;

token1

IERC20Metadata public token1;

maxSlippage

should we change it to mutable state variable, and settable by who?

uint24 public maxSlippage;

oracle

IOracleWrapper public oracle;

_guardian

address internal immutable _guardian;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_managerFeePIPS

uint256 internal _managerFeePIPS;

Functions

onlyMetaVault

modifier onlyMetaVault();

onlyManager

modifier onlyManager();

onlyGuardian

modifier onlyGuardian();

constructor

constructor(address guardian_);

initialize

initialize function to delegate call onced the beacon proxy is deployed, for initializing the valantis module. who can call deposit and withdraw functions.

function initialize(
    address pool_,
    uint256 init0_,
    uint256 init1_,
    uint24 maxSlippage_,
    address metaVault_
) external initializer;

Parameters

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_)
    external
    virtual
    onlyMetaVault;

Parameters

pause

function used to pause the module.

only callable by guardian

function pause() external onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external onlyGuardian;

setALMAndManagerFees

set HOT, oracle (wrapper of HOT) and init manager fees function.

function setALMAndManagerFees(
    address alm_,
    address oracle_
) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

function withdraw(
    address receiver_,
    uint256 proportion_
)
    public
    virtual
    onlyMetaVault
    nonReentrant
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

function withdrawManagerBalance()
    external
    whenNotPaused
    nonReentrant
    returns (uint256 amount0, uint256 amount1);

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_)
    external
    whenNotPaused
    onlyManager;

Parameters

setPriceBounds

fucntion used to set range on valantis AMM

function setPriceBounds(
    uint160 sqrtPriceLowX96_,
    uint160 sqrtPriceHighX96_,
    uint160 expectedSqrtSpotPriceUpperX96_,
    uint160 expectedSqrtSpotPriceLowerX96_
) external onlyManager;

Parameters

swap

function to swap token0->token1 or token1->token0 and then change inventory.

function swap(
    bool zeroForOne_,
    uint256 expectedMinReturn_,
    uint256 amountIn_,
    address router_,
    uint160 expectedSqrtSpotPriceUpperX96_,
    uint160 expectedSqrtSpotPriceLowerX96_,
    bytes calldata payload_
) external onlyManager whenNotPaused;

Parameters

managerBalance0

function used to get manager token0 balance.

amount of fees in token0 that manager have not taken yet.

function managerBalance0() external view returns (uint256 fees0);

Returns

managerBalance1

function used to get manager token1 balance.

amount of fees in token1 that manager have not taken yet.

function managerBalance1() external view returns (uint256 fees1);

Returns

validateRebalance

function used to validate if module state is not manipulated before rebalance.

function validateRebalance(
    IOracleWrapper oracle_,
    uint24 maxDeviation_
) external view;

Parameters

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying() external view returns (uint256, uint256);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96_)
    external
    view
    returns (uint256, uint256);

Parameters

Returns

guardian

function used to get the address that can pause the module.

function guardian() external view returns (address);

Returns

_initializePosition

function _initializePosition() internal;

_checkMinReturn

function _checkMinReturn(
    bool zeroForOne_,
    uint256 expectedMinReturn_,
    uint256 amountIn_,
    uint8 decimals0_,
    uint8 decimals1_
) internal view;

Routers

Content

• Arrakis Public Vault Router
• Router Swap Executor
• Router Swap Resolver

ArrakisPublicVaultRouter

Git Source

Inherits: IArrakisPublicVaultRouter, ReentrancyGuard, Ownable, Pausable

State Variables

nativeToken

address public immutable nativeToken;

permit2

IPermit2 public immutable permit2;

factory

IArrakisMetaVaultFactory public immutable factory;

weth

IWETH9 public immutable weth;

swapper

IRouterSwapExecutor public swapper;

Functions

onlyPublicVault

modifier onlyPublicVault(address vault_);

constructor

constructor(
    address nativeToken_,
    address permit2_,
    address owner_,
    address factory_,
    address weth_
);

pause

function used to pause the router.

only callable by owner

function pause() external onlyOwner;

unpause

function used to unpause the router.

only callable by owner

function unpause() external onlyOwner;

updateSwapExecutor

function updateSwapExecutor(address swapper_)
    external
    whenNotPaused
    onlyOwner;

addLiquidity

addLiquidity adds liquidity to meta vault of interest (mints L tokens)

function addLiquidity(AddLiquidityData memory params_)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.vault)
    returns (uint256 amount0, uint256 amount1, uint256 sharesReceived);

Parameters

Returns

swapAndAddLiquidity

swapAndAddLiquidity transfer tokens to and calls RouterSwapExecutor

function swapAndAddLiquidity(SwapAndAddData memory params_)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.addData.vault)
    returns (
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

Parameters

Returns

removeLiquidity

removeLiquidity removes liquidity from vault and burns LP tokens

function removeLiquidity(RemoveLiquidityData memory params_)
    external
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.vault)
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

addLiquidityPermit2

addLiquidityPermit2 adds liquidity to public vault of interest (mints LP tokens)

function addLiquidityPermit2(AddLiquidityPermit2Data memory params_)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.addData.vault)
    returns (uint256 amount0, uint256 amount1, uint256 sharesReceived);

Parameters

Returns

swapAndAddLiquidityPermit2

swapAndAddLiquidityPermit2 transfer tokens to and calls RouterSwapExecutor

function swapAndAddLiquidityPermit2(
    SwapAndAddPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.swapAndAddData.addData.vault)
    returns (
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

Parameters

Returns

removeLiquidityPermit2

removeLiquidityPermit2 removes liquidity from vault and burns LP tokens

function removeLiquidityPermit2(
    RemoveLiquidityPermit2Data memory params_
)
    external
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.removeData.vault)
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

wrapAndAddLiquidity

wrapAndAddLiquidity wrap eth and adds liquidity to meta vault of interest (mints L tokens)

function wrapAndAddLiquidity(AddLiquidityData memory params_)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.vault)
    returns (uint256 amount0, uint256 amount1, uint256 sharesReceived);

Parameters

Returns

wrapAndSwapAndAddLiquidity

wrapAndSwapAndAddLiquidity wrap eth and transfer tokens to and calls RouterSwapExecutor

function wrapAndSwapAndAddLiquidity(SwapAndAddData memory params_)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.addData.vault)
    returns (
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

Parameters

Returns

wrapAndAddLiquidityPermit2

wrapAndAddLiquidityPermit2 wrap eth and adds liquidity to public vault of interest (mints LP tokens)

hack to get rid of stack too depth

function wrapAndAddLiquidityPermit2(
    AddLiquidityPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.addData.vault)
    returns (uint256 amount0, uint256 amount1, uint256 sharesReceived);

Parameters

Returns

wrapAndSwapAndAddLiquidityPermit2

wrapAndSwapAndAddLiquidityPermit2 wrap eth and transfer tokens to and calls RouterSwapExecutor

function wrapAndSwapAndAddLiquidityPermit2(
    SwapAndAddPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPublicVault(params_.swapAndAddData.addData.vault)
    returns (
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

Parameters

Returns

receive

hack to get rid of stack too depth

receive() external payable;

getMintAmounts

getMintAmounts used to get the shares we can mint from some max amounts.

function getMintAmounts(
    address vault_,
    uint256 maxAmount0_,
    uint256 maxAmount1_
)
    external
    view
    returns (
        uint256 shareToMint,
        uint256 amount0ToDeposit,
        uint256 amount1ToDeposit
    );

Parameters

Returns

_addLiquidity

function _addLiquidity(
    address vault_,
    uint256 amount0_,
    uint256 amount1_,
    uint256 shares_,
    address receiver_,
    address token0_,
    address token1_
) internal;

_swapAndAddLiquidity

function _swapAndAddLiquidity(
    SwapAndAddData memory params_,
    address token0_,
    address token1_
)
    internal
    returns (
        uint256 amount0Use,
        uint256 amount1Use,
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

_swapAndAddLiquiditySendBackLeftOver

function _swapAndAddLiquiditySendBackLeftOver(
    SwapAndAddData memory params_,
    address token0_,
    address token1_
)
    internal
    returns (
        uint256 amount0,
        uint256 amount1,
        uint256 sharesReceived,
        uint256 amount0Diff,
        uint256 amount1Diff
    );

_removeLiquidity

function _removeLiquidity(RemoveLiquidityData memory params_)
    internal
    returns (uint256 amount0, uint256 amount1);

_permit2AddLengthOne

function _permit2AddLengthOne(
    AddLiquidityPermit2Data memory params_,
    address token0_,
    address token1_,
    uint256 amount0_,
    uint256 amount1_
) internal;

_permit2AddLengthOneOrTwo

function _permit2AddLengthOneOrTwo(
    AddLiquidityPermit2Data memory params_,
    address token0_,
    address token1_,
    uint256 amount0_,
    uint256 amount1_
) internal;

_permit2Add

function _permit2Add(
    uint256 permittedLength_,
    AddLiquidityPermit2Data memory params_,
    address token0_,
    address token1_,
    uint256 amount0_,
    uint256 amount1_
) internal;

_permit2SwapAndAddLengthOne

function _permit2SwapAndAddLengthOne(
    SwapAndAddPermit2Data memory params_,
    address token0_,
    address token1_
) internal;

_permit2SwapAndAddLengthOneOrTwo

function _permit2SwapAndAddLengthOneOrTwo(
    SwapAndAddPermit2Data memory params_,
    address token0_,
    address token1_
) internal;

_permit2SwapAndAdd

function _permit2SwapAndAdd(
    uint256 permittedLength_,
    SwapAndAddPermit2Data memory params_,
    address token0_,
    address token1_
) internal;

_getMintAmounts

function _getMintAmounts(
    address vault_,
    uint256 maxAmount0_,
    uint256 maxAmount1_
)
    internal
    view
    returns (
        uint256 shareToMint,
        uint256 amount0ToDeposit,
        uint256 amount1ToDeposit
    );

RouterSwapExecutor

Git Source

Inherits: IRouterSwapExecutor

State Variables

router

address public immutable router;

nativeToken

address public immutable nativeToken;

Functions

onlyRouter

modifier onlyRouter();

constructor

constructor(address router_, address nativeToken_);

swap

function used to swap tokens.

function swap(SwapAndAddData memory params_)
    external
    payable
    onlyRouter
    returns (uint256 amount0Diff, uint256 amount1Diff);

Parameters

Returns

receive

receive() external payable;

RouterSwapResolver

Git Source

Inherits: IRouterSwapResolver

State Variables

router

IArrakisPublicVaultRouter public immutable router;

Functions

constructor

constructor(address router_);

calculateSwapAmount

function calculateSwapAmount(
    IArrakisMetaVault vault_,
    uint256 amount0In_,
    uint256 amount1In_,
    uint256 price18Decimals_
) external view returns (bool zeroForOne, uint256 swapAmount);

_getUnderlyingOrLiquidity

function _getUnderlyingOrLiquidity(IArrakisMetaVault vault_)
    internal
    view
    returns (uint256 gross0, uint256 gross1);

Roter Structs

Content

• AddLiquidityData
• AddLiquidityPermit2Data
• RemoveLiquidityData
• RemoveLiquidityPermit2Data
• SwapAndAddData
• SwapAndAddPermit2Data
• SwapData

AddLiquidityData

Git Source

struct AddLiquidityData {
    uint256 amount0Max;
    uint256 amount1Max;
    uint256 amount0Min;
    uint256 amount1Min;
    uint256 amountSharesMin;
    address vault;
    address receiver;
}

Variables

AddLiquidityPermit2Data

Git Source

struct AddLiquidityPermit2Data {
    AddLiquidityData addData;
    PermitBatchTransferFrom permit;
    bytes signature;
}

Variables

RemoveLiquidityData

Git Source

struct RemoveLiquidityData {
    uint256 burnAmount;
    uint256 amount0Min;
    uint256 amount1Min;
    address vault;
    address payable receiver;
}

Variables

RemoveLiquidityPermit2Data

Git Source

struct RemoveLiquidityPermit2Data {
    RemoveLiquidityData removeData;
    PermitTransferFrom permit;
    bytes signature;
}

Variables

SwapAndAddData

Git Source

struct SwapAndAddData {
    SwapData swapData;
    AddLiquidityData addData;
}

Variables

SwapAndAddPermit2Data

Git Source

struct SwapAndAddPermit2Data {
    SwapAndAddData swapAndAddData;
    PermitBatchTransferFrom permit;
    bytes signature;
}

SwapData

Git Source

struct SwapData {
    bytes swapPayload;
    uint256 amountInSwap;
    uint256 amountOutSwap;
    address swapRouter;
    bool zeroForOne;
}

Variables

Admin and Security

Content

• Arrakis Standard Manager
• Guardian
• Pauser
• TimeLock

ArrakisStandardManager

Git Source

Inherits: IArrakisStandardManager, IManager, Ownable, ReentrancyGuardUpgradeable, PausableUpgradeable

State Variables

defaultFeePIPS

uint256 public immutable defaultFeePIPS;

nativeToken

address public immutable nativeToken;

nativeTokenDecimals

uint8 public immutable nativeTokenDecimals;

defaultReceiver

address public defaultReceiver;

receiversByToken

mapping(address => address) public receiversByToken;

vaultInfo

mapping(address => VaultInfo) public vaultInfo;

pendingFeeIncrease

mapping(address => FeeIncrease) public pendingFeeIncrease;

factory

address public factory;

_guardian

address internal immutable _guardian;

_vaults

EnumerableSet.AddressSet internal _vaults;

Functions

onlyVaultOwner

modifier onlyVaultOwner(address vault_);

onlyWhitelistedVault

modifier onlyWhitelistedVault(address vault_);

onlyGuardian

modifier onlyGuardian();

constructor

constructor(
    uint256 defaultFeePIPS_,
    address nativeToken_,
    uint8 nativeTokenDecimals_,
    address guardian_
);

initialize

function used to initialize standard manager proxy.

we are not checking if the default fee pips is not zero, to have the option to set 0 as default fee pips.

function initialize(
    address owner_,
    address defaultReceiver_,
    address factory_
) external initializer;

Parameters

pause

function used to pause the manager.

only callable by guardian

function pause() external onlyGuardian;

unpause

function used to unpause the manager.

only callable by guardian

function unpause() external onlyGuardian;

setDefaultReceiver

function used to set the default receiver of tokens earned.

function setDefaultReceiver(address newDefaultReceiver_)
    external
    onlyOwner;

Parameters

setReceiverByToken

function used to set receiver of a specific token.

function setReceiverByToken(
    address vault_,
    bool isSetReceiverToken0_,
    address receiver_
) external onlyOwner onlyWhitelistedVault(vault_);

Parameters

decreaseManagerFeePIPS

function used to decrease the fees taken by manager for a specific vault.

function decreaseManagerFeePIPS(
    address vault_,
    uint24 newFeePIPS_
) external onlyOwner onlyWhitelistedVault(vault_);

Parameters

finalizeIncreaseManagerFeePIPS

function used to finalize a time lock fees increase on a vault.

function finalizeIncreaseManagerFeePIPS(address vault_)
    external
    onlyOwner;

Parameters

submitIncreaseManagerFeePIPS

function used to submit a fees increase in a managed vault.

function submitIncreaseManagerFeePIPS(
    address vault_,
    uint24 newFeePIPS_
) external onlyOwner onlyWhitelistedVault(vault_);

Parameters

withdrawManagerBalance

function used by manager to get his balance of fees earned on a vault.

function withdrawManagerBalance(address vault_)
    external
    onlyOwner
    nonReentrant
    whenNotPaused
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

rebalance

function used to manage vault's strategy.

function rebalance(
    address vault_,
    bytes[] calldata payloads_
) external nonReentrant whenNotPaused onlyWhitelistedVault(vault_);

Parameters

setModule

function used to set a new module (strategy) for the vault.

only public vault should have this check.

function setModule(
    address vault_,
    address module_,
    bytes[] calldata payloads_
) external whenNotPaused onlyWhitelistedVault(vault_);

Parameters

initManagement

function used to init management of a meta vault.

function initManagement(SetupParams calldata params_)
    external
    whenNotPaused;

Parameters

updateVaultInfo

function used to update meta vault management informations.

function updateVaultInfo(SetupParams calldata params_)
    external
    whenNotPaused
    onlyWhitelistedVault(params_.vault)
    onlyVaultOwner(params_.vault);

Parameters

receive

receive() external payable;

announceStrategy

function used to announce the strategy that the vault will follow.

function announceStrategy(
    address vault_,
    string memory strategy_
) external onlyWhitelistedVault(vault_);

Parameters

initializedVaults

function used to get a list of managed vaults.

function initializedVaults(
    uint256 startIndex_,
    uint256 endIndex_
) external view whenNotPaused returns (address[] memory);

Parameters

numInitializedVaults

function used to get the number of vault under management.

function numInitializedVaults()
    external
    view
    returns (uint256 numberOfVaults);

guardian

address of the pauser of manager.

function guardian() external view returns (address);

Returns

isManaged

function used to know if a vault is under management by this manager.

function isManaged(address vault_) external view returns (bool);

Parameters

Returns

getInitManagementSelector

function used to know the selector of initManagement functions.

function getInitManagementSelector()
    external
    pure
    returns (bytes4 selector);

_initManagement

function _initManagement(SetupParams memory params_) internal;

_updateParamsChecks

function _updateParamsChecks(SetupParams memory params_)
    internal
    view;

Guardian

Git Source

Inherits: Ownable, IGuardian

State Variables

pauser

address public pauser;

Functions

constructor

constructor(address owner_, address pauser_);

setPauser

function to set the pauser of Arrakis protocol.

function setPauser(address newPauser_) external onlyOwner;

Pauser

Git Source

Inherits: IPauser, Ownable

State Variables

_pausers

EnumerableSet.AddressSet internal _pausers;

Functions

constructor

constructor(address pauser_, address owner_);

pause

function pause(address target_) external override;

whitelistPausers

function whitelistPausers(address[] calldata pausers_)
    external
    override
    onlyOwner;

blacklistPausers

function blacklistPausers(address[] calldata pausers_)
    external
    override
    onlyOwner;

isPauser

function isPauser(address account_) public view returns (bool);

TimeLock

Git Source

Inherits: TimelockController, ITimeLock

Functions

constructor

constructor(
    uint256 minDelay,
    address[] memory proposers,
    address[] memory executors,
    address admin
) TimelockController(minDelay, proposers, executors, admin);

updateDelay

override updateDelay function of TimelockController to not allow update of delay.

function updateDelay(uint256) external pure override;

More

This page contains the whole Arrakis Modular smart contracts documentation, which was autogenerated with Foundry forge doc. This serves as a complete reference for developers and facilitates a detailed search by terms.

Contents

• abstracts
• constants
• hooks
• interfaces
• modules
• structs
• utils
• ArrakisMetaVaultFactory
• ArrakisMetaVaultPrivate
• ArrakisMetaVaultPublic
• ArrakisPublicVaultRouter
• ArrakisStandardManager
• CreationCodePrivateVault
• CreationCodePublicVault
• Guardian
• ModulePrivateRegistry
• ModulePublicRegistry
• Pauser
• PrivateVaultNFT
• RenderController
• RouterSwapExecutor
• RouterSwapResolver
• TimeLock

Contents

• ArrakisMetaVault
• ModuleRegistry
• ValantisModule

ArrakisMetaVault

Git Source

Inherits: IArrakisMetaVault, ReentrancyGuard, Initializable

State Variables

moduleRegistry

address public immutable moduleRegistry;

token0

address public immutable token0;

token1

address public immutable token1;

manager

address public immutable manager;

module

IArrakisLPModule public module;

_whitelistedModules

EnumerableSet.AddressSet internal _whitelistedModules;

Functions

onlyOwnerCustom

modifier onlyOwnerCustom();

onlyManager

modifier onlyManager();

constructor

constructor(
    address moduleRegistry_,
    address manager_,
    address token0_,
    address token1_
);

initialize

function initialize(address module_) external initializer;

setModule

function used to set module

function setModule(
    address module_,
    bytes[] calldata payloads_
) external onlyManager nonReentrant;

Parameters

whitelistModules

function used to whitelist modules that can used by manager.

we transfer here all tokens to the new module.

function whitelistModules(
    address[] calldata beacons_,
    bytes[] calldata data_
) external onlyOwnerCustom;

Parameters

blacklistModules

function used to blacklist modules that can used by manager.

function blacklistModules(address[] calldata modules_)
    external
    onlyOwnerCustom;

Parameters

whitelistedModules

function used to get the list of modules whitelisted.

function whitelistedModules()
    external
    view
    returns (address[] memory modules);

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying()
    public
    view
    returns (uint256 amount0, uint256 amount1);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96_)
    external
    view
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

_withdraw

function _withdraw(
    address receiver_,
    uint256 proportion_
) internal returns (uint256 amount0, uint256 amount1);

_withdrawManagerBalance

function _withdrawManagerBalance(IArrakisLPModule module_)
    internal
    returns (uint256 amount0, uint256 amount1);

_call

function _call(address module_, bytes memory data_) internal;

_onlyOwnerCheck

function _onlyOwnerCheck() internal view virtual;

ModuleRegistry

Git Source

Inherits: IModuleRegistry, Ownable, Initializable

State Variables

factory

IArrakisMetaVaultFactory public factory;

admin

should be a timelock contract.

address public immutable admin;

_guardian

address internal immutable _guardian;

_beacons

EnumerableSet.AddressSet internal _beacons;

Functions

constructor

constructor(address owner_, address guardian_, address admin_);

initialize

function used to initialize module registry.

function initialize(address factory_) external initializer;

Parameters

beacons

function to get the whitelisted list of IBeacon that have module as implementation.

function beacons() external view returns (address[] memory);

Returns

beaconsContains

function to know if the beacons enumerableSet contain beacon_

function beaconsContains(address beacon_)
    external
    view
    returns (bool isContained);

Parameters

guardian

function used to get the guardian address of arrakis protocol.

function guardian() external view returns (address);

Returns

whitelistBeacons

function used to whitelist IBeacon that contain implementation of valid module.

function whitelistBeacons(address[] calldata beacons_)
    external
    onlyOwner;

Parameters

blacklistBeacons

function used to blacklist IBeacon that contain implementation of unvalid (from now) module.

function blacklistBeacons(address[] calldata beacons_)
    external
    onlyOwner;

Parameters

_createModule

function _createModule(
    address vault_,
    address beacon_,
    bytes calldata payload_
) internal returns (address module);

_checkVaultNotAddressZero

function _checkVaultNotAddressZero(address vault_) internal pure;

ValantisModule

Git Source

Inherits: IArrakisLPModule, IValantisHOTModule, PausableUpgradeable, ReentrancyGuardUpgradeable

BeaconProxy be careful for changing implementation with upgrade.

State Variables

metaVault

IArrakisMetaVault public metaVault;

pool

ISovereignPool public pool;

alm

IHOT public alm;

token0

IERC20Metadata public token0;

token1

IERC20Metadata public token1;

maxSlippage

should we change it to mutable state variable, and settable by who?

uint24 public maxSlippage;

oracle

IOracleWrapper public oracle;

_guardian

address internal immutable _guardian;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_managerFeePIPS

uint256 internal _managerFeePIPS;

Functions

onlyMetaVault

modifier onlyMetaVault();

onlyManager

modifier onlyManager();

onlyGuardian

modifier onlyGuardian();

constructor

constructor(address guardian_);

initialize

initialize function to delegate call onced the beacon proxy is deployed, for initializing the valantis module. who can call deposit and withdraw functions.

function initialize(
    address pool_,
    uint256 init0_,
    uint256 init1_,
    uint24 maxSlippage_,
    address metaVault_
) external initializer;

Parameters

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_)
    external
    virtual
    onlyMetaVault;

Parameters

pause

function used to pause the module.

only callable by guardian

function pause() external onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external onlyGuardian;

setALMAndManagerFees

set HOT, oracle (wrapper of HOT) and init manager fees function.

function setALMAndManagerFees(
    address alm_,
    address oracle_
) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

function withdraw(
    address receiver_,
    uint256 proportion_
)
    public
    virtual
    onlyMetaVault
    nonReentrant
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

function withdrawManagerBalance()
    external
    whenNotPaused
    nonReentrant
    returns (uint256 amount0, uint256 amount1);

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_)
    external
    whenNotPaused
    onlyManager;

Parameters

setPriceBounds

fucntion used to set range on valantis AMM

function setPriceBounds(
    uint160 sqrtPriceLowX96_,
    uint160 sqrtPriceHighX96_,
    uint160 expectedSqrtSpotPriceUpperX96_,
    uint160 expectedSqrtSpotPriceLowerX96_
) external onlyManager;

Parameters

swap

function to swap token0->token1 or token1->token0 and then change inventory.

function swap(
    bool zeroForOne_,
    uint256 expectedMinReturn_,
    uint256 amountIn_,
    address router_,
    uint160 expectedSqrtSpotPriceUpperX96_,
    uint160 expectedSqrtSpotPriceLowerX96_,
    bytes calldata payload_
) external onlyManager whenNotPaused;

Parameters

managerBalance0

function used to get manager token0 balance.

amount of fees in token0 that manager have not taken yet.

function managerBalance0() external view returns (uint256 fees0);

Returns

managerBalance1

function used to get manager token1 balance.

amount of fees in token1 that manager have not taken yet.

function managerBalance1() external view returns (uint256 fees1);

Returns

validateRebalance

function used to validate if module state is not manipulated before rebalance.

function validateRebalance(
    IOracleWrapper oracle_,
    uint24 maxDeviation_
) external view;

Parameters

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying() external view returns (uint256, uint256);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96_)
    external
    view
    returns (uint256, uint256);

Parameters

Returns

guardian

function used to get the address that can pause the module.

function guardian() external view returns (address);

Returns

_initializePosition

function _initializePosition() internal;

_checkMinReturn

function _checkMinReturn(
    bool zeroForOne_,
    uint256 expectedMinReturn_,
    uint256 amountIn_,
    uint8 decimals0_,
    uint8 decimals1_
) internal view;

Contents

• CArrakis constants

Constants

Git Source

MINIMUM_LIQUIDITY

uint256 constant MINIMUM_LIQUIDITY = 10 ** 3;

BASE

uint256 constant BASE = 1e18;

PIPS

uint24 constant PIPS = 1_000_000;

TEN_PERCENT

uint24 constant TEN_PERCENT = 100_000;

WEEK

uint256 constant WEEK = 604_800;

NATIVE_COIN

address constant NATIVE_COIN =
    0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

NATIVE_COIN_DECIMALS

uint8 constant NATIVE_COIN_DECIMALS = 18;

Contents

• ArrakisPrivateHook

ArrakisPrivateHook

Git Source

Inherits: IHooks, IArrakisPrivateHook

State Variables

module

address public immutable module;

poolManager

address public immutable poolManager;

vault

address public immutable vault;

manager

address public immutable manager;

fee

uint24 public fee;

Functions

constructor

constructor(address module_, address poolManager_);

setFee

function setFee(PoolKey calldata poolKey_, uint24 fee_) external;

beforeInitialize

The hook called before the state of a pool is initialized.

function not implemented, ArrakisPrivateHook will not support this hook.

function beforeInitialize(
    address,
    PoolKey calldata,
    uint160,
    bytes calldata
) external virtual returns (bytes4);

afterInitialize

The hook called after the state of a pool is initialized.

function not implemented, ArrakisPrivateHook will not support this hook.

function afterInitialize(
    address,
    PoolKey calldata,
    uint160,
    int24,
    bytes calldata
) external virtual returns (bytes4);

beforeAddLiquidity

The hook called before liquidity is added

function beforeAddLiquidity(
    address sender,
    PoolKey calldata,
    IPoolManager.ModifyLiquidityParams calldata,
    bytes calldata
) external virtual returns (bytes4);

Parameters

afterAddLiquidity

The hook called after liquidity is added.

function not implemented, ArrakisPrivateHook will not support this hook.

function afterAddLiquidity(
    address,
    PoolKey calldata,
    IPoolManager.ModifyLiquidityParams calldata,
    BalanceDelta,
    BalanceDelta,
    bytes calldata
) external virtual returns (bytes4, BalanceDelta);

beforeRemoveLiquidity

The hook called before liquidity is removed.

function beforeRemoveLiquidity(
    address sender,
    PoolKey calldata,
    IPoolManager.ModifyLiquidityParams calldata,
    bytes calldata
) external virtual returns (bytes4);

Parameters

afterRemoveLiquidity

The hook called after liquidity is removed.

function not implemented, ArrakisPrivateHook will not support this hook.

function afterRemoveLiquidity(
    address,
    PoolKey calldata,
    IPoolManager.ModifyLiquidityParams calldata,
    BalanceDelta,
    BalanceDelta,
    bytes calldata
) external virtual returns (bytes4, BalanceDelta);

beforeSwap

The hook called before a swap.

function not implemented, ArrakisPrivateHook will not support this hook.

function beforeSwap(
    address,
    PoolKey calldata,
    IPoolManager.SwapParams calldata,
    bytes calldata
) external virtual returns (bytes4, BeforeSwapDelta, uint24);

afterSwap

The hook called after a swap.

function not implemented, ArrakisPrivateHook will not support this hook.

function afterSwap(
    address,
    PoolKey calldata,
    IPoolManager.SwapParams calldata,
    BalanceDelta,
    bytes calldata
) external virtual returns (bytes4, int128);

beforeDonate

The hook called before donate.

function not implemented, ArrakisPrivateHook will not support this hook.

function beforeDonate(
    address,
    PoolKey calldata,
    uint256,
    uint256,
    bytes calldata
) external virtual returns (bytes4);

afterDonate

The hook called after donate.

function not implemented, ArrakisPrivateHook will not support this hook.

function afterDonate(
    address,
    PoolKey calldata,
    uint256,
    uint256,
    bytes calldata
) external virtual returns (bytes4);

Contents

• AggregatorV3Interface
• IArrakisLPModule
• IArrakisLPModuleID
• IArrakisLPModulePrivate
• IArrakisLPModulePublic
• IArrakisMetaVault
• IArrakisMetaVaultFactory
• IArrakisMetaVaultPrivate
• IArrakisMetaVaultPublic
• IArrakisPrivateHook
• IArrakisPublicVaultRouter
• IArrakisStandardManager
• IBunkerModule
• ICreationCode
• IGuardian
• IHOTExecutor
• IManager
• IModulePrivateRegistry
• IModulePublicRegistry
• IModuleRegistry
• IOracleWrapper
• IOwnable
• IPausable
• IPauser
• IPermit2
• IPrivateVaultNFT
• IRenderController
• IResolver
• IRouterSwapExecutor
• IRouterSwapResolver
• ISovereignPool
• ITimeLock
• IValantisHOTModule
• IWETH9

AggregatorV3Interface

Git Source

Functions

decimals

function decimals() external view returns (uint8);

description

function description() external view returns (string memory);

version

function version() external view returns (uint256);

getRoundData

function getRoundData(uint80 _roundId)
    external
    view
    returns (
        uint80 roundId,
        int256 answer,
        uint256 startedAt,
        uint256 updatedAt,
        uint80 answeredInRound
    );

latestRoundData

function latestRoundData()
    external
    view
    returns (
        uint80 roundId,
        int256 answer,
        uint256 startedAt,
        uint256 updatedAt,
        uint80 answeredInRound
    );

IArrakisLPModule

Git Source

Author: Arrakis Finance

Module interfaces, modules are implementing differents strategies that an arrakis module can use.

Functions

pause

function used to pause the module.

only callable by guardian

function pause() external;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external;

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

function withdraw(
    address receiver_,
    uint256 proportion_
) external returns (uint256 amount0, uint256 amount1);

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

function withdrawManagerBalance()
    external
    returns (uint256 amount0, uint256 amount1);

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_) external;

Parameters

metaVault

function used to get metaVault as IArrakisMetaVault.

function metaVault() external view returns (IArrakisMetaVault);

Returns

guardian

function used to get the address that can pause the module.

function guardian() external view returns (address);

Returns

managerBalance0

function used to get manager token0 balance.

amount of fees in token0 that manager have not taken yet.

function managerBalance0() external view returns (uint256);

Returns

managerBalance1

function used to get manager token1 balance.

amount of fees in token1 that manager have not taken yet.

function managerBalance1() external view returns (uint256);

Returns

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

token0

function used to get token0 as IERC20Metadata.

function token0() external view returns (IERC20Metadata);

Returns

token1

function used to get token1 as IERC20Metadata.

function token1() external view returns (IERC20Metadata);

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying()
    external
    view
    returns (uint256 amount0, uint256 amount1);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96_)
    external
    view
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

validateRebalance

function used to validate if module state is not manipulated before rebalance.

function validateRebalance(
    IOracleWrapper oracle_,
    uint24 maxDeviation_
) external view;

Parameters

Events

LogWithdraw

Event describing a withdrawal of participation by an user inside this module.

withdraw action can be indexed by receiver.

event LogWithdraw(
    address indexed receiver,
    uint256 proportion,
    uint256 amount0,
    uint256 amount1
);

Parameters

LogWithdrawManagerBalance

Event describing a manager fee withdrawal.

event LogWithdrawManagerBalance(
    address manager, uint256 amount0, uint256 amount1
);

Parameters

LogSetManagerFeePIPS

Event describing manager set his fees.

event LogSetManagerFeePIPS(uint256 oldFee, uint256 newFee);

Parameters

Errors

AddressZero

triggered when an address that should not be zero is equal to address zero.

error AddressZero();

OnlyMetaVault

triggered when the caller is different than the metaVault that own this module.

error OnlyMetaVault(address caller, address metaVault);

OnlyManager

triggered when the caller is different than the manager defined by the metaVault.

error OnlyManager(address caller, address manager);

ProportionZero

triggered if proportion of minting or burning is zero.

error ProportionZero();

ProportionGtBASE

triggered if during withdraw more than 100% of the position.

error ProportionGtBASE();

NewFeesGtPIPS

triggered when manager want to set his more earned by the position than 100% of fees earned.

error NewFeesGtPIPS(uint256 newFees);

SameManagerFee

triggered when manager is setting the same fees that already active.

error SameManagerFee();

InitsAreZeros

triggered when inits values are zeros.

error InitsAreZeros();

OnlyGuardian

triggered when pause/unpaused function is called by someone else than guardian.

error OnlyGuardian();

IArrakisLPModuleID

Git Source

Functions

id

function id() external view returns (bytes32);

IArrakisLPModulePrivate

Git Source

expose a deposit function for that can deposit any share of token0 and token1.

this deposit feature will be used by private actor.

Functions

fund

deposit function for private vault.

function fund(
    address depositor_,
    uint256 amount0_,
    uint256 amount1_
) external payable;

Parameters

Events

LogFund

event emitted when owner of private fund the private vault.

event LogFund(address depositor, uint256 amount0, uint256 amount1);

Parameters

Errors

DepositZero

error DepositZero();

IArrakisLPModulePublic

Git Source

expose a deposit function for that can deposit a specific share of token0 and token1.

this deposit feature will be used by public actor.

Functions

deposit

deposit function for public vault.

function deposit(
    address depositor_,
    uint256 proportion_
) external payable returns (uint256 amount0, uint256 amount1);

Parameters

Returns

Events

LogDeposit

Event describing a deposit done by an user inside this module.

deposit action can be indexed by depositor.

event LogDeposit(
    address depositor,
    uint256 proportion,
    uint256 amount0,
    uint256 amount1
);

Parameters

IArrakisMetaVault

Git Source

IArrakisMetaVault is a vault that is able to invest dynamically deposited tokens into protocols through his module.

Functions

initialize

function used to initialize default module.

function initialize(address module_) external;

Parameters

setModule

function used to set module

function setModule(
    address module_,
    bytes[] calldata payloads_
) external;

Parameters

whitelistModules

function used to whitelist modules that can used by manager.

function whitelistModules(
    address[] calldata beacons_,
    bytes[] calldata data_
) external;

Parameters

blacklistModules

function used to blacklist modules that can used by manager.

function blacklistModules(address[] calldata modules_) external;

Parameters

whitelistedModules

function used to get the list of modules whitelisted.

function whitelistedModules()
    external
    view
    returns (address[] memory modules);

Returns

totalUnderlying

function used to get the amount of token0 and token1 sitting on the position.

function totalUnderlying()
    external
    view
    returns (uint256 amount0, uint256 amount1);

Returns

totalUnderlyingAtPrice

function used to get the amounts of token0 and token1 sitting on the position for a specific price.

function totalUnderlyingAtPrice(uint160 priceX96)
    external
    view
    returns (uint256 amount0, uint256 amount1);

Parameters

Returns

getInits

function used to get the initial amounts needed to open a position.

function getInits()
    external
    view
    returns (uint256 init0, uint256 init1);

Returns

token0

function used to get the address of token0.

function token0() external view returns (address);

token1

function used to get the address of token1.

function token1() external view returns (address);

manager

function used to get manager address.

function manager() external view returns (address);

module

function used to get module used to open/close/manager a position.

function module() external view returns (IArrakisLPModule);

moduleRegistry

function used to get module registry.

function moduleRegistry() external view returns (address registry);

Returns

Events

LogWithdrawManagerBalance

Event describing a manager fee withdrawal.

event LogWithdrawManagerBalance(uint256 amount0, uint256 amount1);

Parameters

LogSetManager

Event describing owner setting the manager.

event LogSetManager(address manager);

Parameters

LogSetModule

Event describing manager setting the module.

event LogSetModule(address module, bytes[] payloads);

Parameters

LogSetFirstModule

Event describing default module that the vault will be initialized with.

event LogSetFirstModule(address module);

Parameters

LogWhiteListedModules

Event describing list of modules that has been whitelisted by owner.

event LogWhiteListedModules(address[] modules);

Parameters

LogWhitelistedModule

Event describing whitelisted of the first module during vault creation.

event LogWhitelistedModule(address module);

Parameters

LogBlackListedModules

Event describing blacklisting action of modules by owner.

event LogBlackListedModules(address[] modules);

Parameters

Errors

AddressZero

triggered when an address that should not be zero is equal to address zero.

error AddressZero(string property);

OnlyManager

triggered when the caller is different than the manager.

error OnlyManager(address caller, address manager);

CallFailed

triggered when a low level call failed during execution.

error CallFailed();

SameModule

triggered when manager try to set the active module as active.

error SameModule();

SameManager

triggered when owner of the vault try to set the manager with the current manager.

error SameManager();

ModuleNotEmpty

triggered when all tokens withdrawal has been done during a switch of module.

error ModuleNotEmpty(uint256 amount0, uint256 amount1);

AlreadyWhitelisted

triggered when owner try to whitelist a module that has been already whitelisted.

error AlreadyWhitelisted(address module);

NotWhitelistedModule

triggered when owner try to blacklist a module that has not been whitelisted.

error NotWhitelistedModule(address module);

ActiveModule

triggered when owner try to blacklist the active module.

error ActiveModule();

Token0GtToken1

triggered during vault creation if token0 address is greater than token1 address.

error Token0GtToken1();

Token0EqToken1

triggered during vault creation if token0 address is equal to token1 address.

error Token0EqToken1();

NotWhitelistedBeacon

triggered when whitelisting action is occuring and module's beacon is not whitelisted on module registry.

error NotWhitelistedBeacon();

NotSameGuardian

triggered when guardian of the whitelisting module is different than the guardian of the registry.

error NotSameGuardian();

NotImplemented

triggered when a function logic is not implemented.

error NotImplemented();

ArrayNotSameLength

triggered when two arrays suppposed to have the same length, have different length.

error ArrayNotSameLength();

OnlyOwner

triggered when function is called by someone else than the owner.

error OnlyOwner();

WithdrawNotAllowed

triggered when setModule action try to remove funds.

error WithdrawNotAllowed();

PositionNotInitialized

triggered when setModule function end without initiliazePosition call.

error PositionNotInitialized();

NotPositionInitializationCall

triggered when the first external call of setModule function isn't InitializePosition function.

error NotPositionInitializationCall();

IArrakisMetaVaultFactory

Git Source

Functions

pause

function used to pause the factory.

only callable by owner.

function pause() external;

unpause

function used to unpause the factory.

only callable by owner.

function unpause() external;

setManager

function used to set a new manager.

only callable by owner.

function setManager(address newManager_) external;

Parameters

deployPublicVault

function used to deploy ERC20 token wrapped Arrakis Meta Vault.

function deployPublicVault(
    bytes32 salt_,
    address token0_,
    address token1_,
    address owner_,
    address beacon_,
    bytes calldata moduleCreationPayload_,
    bytes calldata initManagementPayload_
) external returns (address vault);

Parameters

Returns

deployPrivateVault

function used to deploy owned Arrakis Meta Vault.

function deployPrivateVault(
    bytes32 salt_,
    address token0_,
    address token1_,
    address owner_,
    address beacon_,
    bytes calldata moduleCreationPayload_,
    bytes calldata initManagementPayload_
) external returns (address vault);

Parameters

Returns

whitelistDeployer

function used to grant the role to deploy to a list of addresses.

function whitelistDeployer(address[] calldata deployers_) external;

Parameters

blacklistDeployer

function used to grant the role to deploy to a list of addresses.

function blacklistDeployer(address[] calldata deployers_) external;

Parameters

getTokenName

get Arrakis Modular standard token name for two corresponding tokens.

function getTokenName(
    address token0_,
    address token1_
) external view returns (string memory);

Parameters

Returns

publicVaults

get a list of public vaults created by this factory

function publicVaults(
    uint256 startIndex_,
    uint256 endIndex_
) external view returns (address[] memory);

Parameters

Returns

numOfPublicVaults

numOfPublicVaults counts the total number of token vaults in existence

function numOfPublicVaults() external view returns (uint256 result);

Returns

isPublicVault

isPublicVault check if the inputed vault is a public vault.

function isPublicVault(address vault_) external view returns (bool);

Parameters

Returns

privateVaults

get a list of private vaults created by this factory

function privateVaults(
    uint256 startIndex_,
    uint256 endIndex_
) external view returns (address[] memory);

Parameters

Returns

numOfPrivateVaults

numOfPrivateVaults counts the total number of private vaults in existence

function numOfPrivateVaults()
    external
    view
    returns (uint256 result);

Returns

isPrivateVault

isPrivateVault check if the inputed vault is a private vault.

function isPrivateVault(address vault_)
    external
    view
    returns (bool);

Parameters

Returns

manager

function used to get the manager of newly deployed vault.

function manager() external view returns (address);

Returns

deployers

function used to get a list of address that can deploy public vault.

function deployers() external view returns (address[] memory);

moduleRegistryPublic

function used to get public module registry.

function moduleRegistryPublic() external view returns (address);

moduleRegistryPrivate

function used to get private module registry.

function moduleRegistryPrivate() external view returns (address);

Events

LogPublicVaultCreation

event emitted when public vault is created by a deployer.

event LogPublicVaultCreation(
    address indexed creator,
    bytes32 salt,
    address token0,
    address token1,
    address owner,
    address module,
    address publicVault,
    address timeLock
);

Parameters

LogPrivateVaultCreation

event emitted when private vault is created.

event LogPrivateVaultCreation(
    address indexed creator,
    bytes32 salt,
    address token0,
    address token1,
    address owner,
    address module,
    address privateVault
);

Parameters