Intro

Welcome to the Arrakis documentation.

Arrakis is a MEV-aware market maker that powers onchain liquidity for token issuers and LPs. We're building the Arrakis Protocol to make onchain liquidity provision more scalable and efficient.

Read this Intro to Arrakis for a high-level overview of the Arrakis Protocol and the Arrakis Pro product that it powers.

Or jump straight into:

• Arrakis Pro Docs
• Developer Docs
• Resources

The liquidity must flow.

Arrakis Protocol

Arrakis Protocol consists of two major infrastructural components:

• Offchain Market Making Infrastructure
• Onchain Smart Contract Framework

Our smart contract framework for DEX integrations (Arrakis Modular) works together with our offchain market making infrastructure. The union of these onchain and offchain components comprise the Arrakis Protocol.

For example, Arrakis Pro on Uniswap V4 is formed by the following components:

• Arrakis Quoter and other offchain market making components to determine dynamic fees.
• Arrakis Modular (smart contract framework) Private Vaults.
• A new custom Arrakis Uniswap V4 Hook to give private access to a given pool as well setting dynamic fees which are respnsive to market conditions.

Arrakis Pro

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

See Arrakis Pro Docs

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, Uniswap v4 and Aerodrome). 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 is trusted by MakerDAO, Lido, EtherFi, Across, Stargate, Gnosis, Redstone, Euler, Redacted Cartel, Angle, Mountain, Kwenta, IndexCoop, Sturdy, Everclear and many more leading protocols. As of October 2024, Arrakis vaults have facilitated over $20B in cumulative trading volume.

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

Arrakis Pro Docs

Here you can learn about the feature set and technical details of Arrakis Pro. What is Arrakis Pro? See the high-level intro

Arrakis Pro is built on Arrakis Modular Private Vaults. Dive into Arrakis Modular Docs to learn about Arrakis Modular smart contracts in-depth.

TLDR

A Private Vault can be thought of as the entrypoint and heads-up display for a single LP to manage their onchain DEX liquidity on a token pair (e.g. ETH/AAVE) in a sophisticated and optimized way. Private Vault ownership is tokenized as an NFT, similar to Uniswap V3 NFTs (pictured below)

Arrakis Pro Vaults are a subset of Private Vaults configured to use Arrakis' proprietary Offchain Management Infrastructure and Liquidity Provision Strategy Templates.

Arrakis Pro Vault Setup

Deployment

For now simply contact us to have an Arrakis engineer deploy and configure an Arrakis Pro vault on your behalf. (If you really want to deploy by yourself see sample deploy script here)

At deployment you choose what initial module your vault uses. See integrations section for more info.

Deposit

After deployment, you can now deposit liquidity into your Arrakis Pro vault.

Deposit Using a Safe and Safe App:

Navigate to your vault owner Safe on Safe App. Then go to Apps -> My custom apps and then add https://app.arrakis.finance/pro as a "Custom Safe App". In the custom safe app you'll see your Pro vault(s) and can use the GUI to deposit with one multi-step Safe transaction.

Deposit Manually:

1. From vault.owner() acct -> call whitelistDepositors on your Vault contract to whitelist the account that will deposit tokens (even owner has to explicitly whitelist itself before depositing).

2. From whitelisted depositor acct -> approve vault.module() contract address as spender of token(s) you will deposit.

3. From whitelisted depositor acct -> Call deposit on your Vault contract to deposit funds. (If depositing native ETH remember to pass a msg.value that matches the amount0/1 argument)

Activation

After deposit your vault is not necessarily activated immediately. To activate your vault and deploy LP into the DEX of interest, you'll need a "strategy config" set on the Arrakis Pro Backend. See strategies section.

Pro Vault Maintenance

NOTE: most maintenance actions are not yet available on the Arrakis Pro UI. But they will be soon. For now if urgent maintenance actions are needed follow this guide.

updateVaultInfo

On the ArraksStandardManager every vault owner has the ability to adjust important management parameters for their vault.

1. View call manager.vaultInfo(address vault) to see current vault info.

2. from vault owner acct -> call manager.updateVaultInfo(struct memory SetupParams) see here where the struct has these fields:

struct SetupParams {
    address vault;
    IOracleWrapper oracle;
    uint24 maxDeviation;
    uint256 cooldownPeriod;
    address executor;
    address stratAnnouncer;
    uint24 maxSlippagePIPS;
}

edit the fields you want to change and copy over the fields from Step 1 that you want to keep the same.

• vault that is the address of your vault. call will fail if msg.sender is not not owner of this vault
• oracle is a smart contract which acts as onchain oracle to police executor actions. Read more about Arrakis Price Oracles
• maxDeviation this is max deviation underlying module spot market can haave from oracle price (in pips)
• cooldownPeriod shortest amount of seconds between any successful management actions on the vault
• executor account which can call management functions for this vault. Pro vaults have 0x420966bCf2A0351F26048cD07076627Cde4f79ac as executor (the Arrakis Pro Backend)
• stratAnnouncer currently unused for now, (in future, account with ability to set vault offchain strategy config via onchain call)
• maxSlippagePIPS maximum slippage from oracle price on management swap actions (in pips)

The ArrakisStandardManager is deployed to address 0x2e6E879648293e939aA68bA4c6c129A1Be733bDA on all networks. See mainnet contract onchain: here

transfer vault

nevertheless you may want to migrate your Arrakis Pro vault to a new owner account. This is as simple as transferring the NFT to the target recipient which can usually be done on any wallet UI directly.

manual steps:

Find your token id of interest and call transferFrom(address from, address to, uint256 tokenId) on the PrivateVaultNFT contract.

• The from is current owner of tokenId and also the acct you are calling from
• The to is your desired recipient of vault control
• The tokenId is the tokenId you found. It is also the keccak256(vaultAddress)

Arrakis PrivateVaultNFT contract is deployed to address 0x44A801e7E2E073bd8bcE4bCCf653239Fa156B762 on all networks. See mainnet contract onchain: here

whitelistModules

Every vault owner has the ability to call whitelistModules(address[] calldata beacons, bytes[] calldata datas) see here

with valid module beacon addresses in the beacons argument and valid module initialization payloads in the datas argument.

Because these may not be simple calls to construct correctly, we recommend reaching out to Arrakis engineers if you want to whitelist new modules.

Integrations

One key feature of Arrakis Modular is the ability to switch between modules, where each module defines the vault's integration with a liquidity consuming dApp. For Arrakis Pro there are currently four potential modules to choose from:

1. Uniswap v4: Supply liquidity to Uniswap V4 with easy batching of liquidity operations on a single pool. Easily migrate token0/token1 liquidity across safe (no hook logic on add or remove liquidity) pools (hooks). Integrates with merkl rewards so that vault LPs can earn them.

2. Aerodrome: Supply liquidity and stake liquidity positions to earn AERO on a single Aerodrome slipstream pool, with easy batching of NFT liquidity position operations (mint, burn, claim rewards).

3. PancakeSwap Infinity: [identical in features to Uniswap V4 module, but code is different]

4. Velodrome: [identical to Aerodrome module, same bytecode]

Because each of these modules use Uniswap V3 style tick math they can all consume the same core strategy templates (with slightly different paylaod encodings) described in the strategies section.

Strategies

Arrakis Pro offers adaptive strategies designed for efficient on-chain liquidity management. These strategies work for all AMMs that are based on Uniswap V3 Math, including Uniswap V4, Aerodrome, Velodrome, and PancakeSwap V4.

• The Bootstrap Strategy is ideal for token launches with imbalanced starting inventories. It deploys liquidity across a full-range position and several narrow “bootstrapping” ranges that hold mostly "base" tokens (as opposed to "quote" tokens like USDC or ETH). As users trade, the strategy captures volatility asymmetrically—accumulating more quote token on buy pressure—and steadily moves toward a 50/50 token balance. Once ~50/50 balance is reached, the strategy stops

• The Flagship Strategy manages mature pools by reacting to price shifts, inventory imbalance, and volatility. It operates in three risk modes adjusting liquidity depth and range width accordingly. During calm markets, it concentrates liquidity to maximize fees and reduce price impact. During volatile markets, it widens ranges and reduces exposure. Rebalancing is based on price and inventory trends, ensuring stability and efficiency.

Together, these strategies guide tokens from launch to maturity. One the one hand, they provide consistent price impact for traders. On the other hand, they ensure a stable inventory balance and fee generation for treasuries.

We are continuously designing tailored strategies for specific token pairs, which may need more frequent rebalances, swapping on third party aggregators or using offchain prediction models, among others.

Bootstrap strategy

Introduction

Uniswap V2 simplicity and symmetric trading curve are ideal for price discovery during token launches. The absence of directional bias implies that trading activity orgaically determines the market price of a token. However, this requires adding liquidity in a 50/50 ratio, which is not practical for most treasuries.

Our bootstrap strategy is designed to leverage the features of concentrated liquidity introduced in Uniswap V3 in order to manage very imbalanced liquidity ratios, for example 80% of a governace token GOV vs 20% of a quote token like ETH or USDC. By asymmetrically absorbing volatility, it captures more of the quote token during buy spikes, progressively converging to a 50/50 token ratio.

From now on we consider an ETH/GOV token pair as an example to describe the strategy implementation.

Implementation

The bootstrap strategy defines a liquidity distribution composed by several ranges

• Full Range: A wide position with both tokens in a 50/50 proportion and acting as the main stabilizer. It provides liquidiity at all possible prices and ensures trading is always possible for this pair.

• Bootstrapping Ranges: Short, sequential ranges with increasing size, initially holding just one token to guide early price movement. They are the core element of this strategy and built such that the price impact for buying and selling orders are very close to each other. These ranges are able to capture ETH during upside movements in price while providing an almost unbiased experience for traders.

• Price Discovery Range: A long-range position for capturing additional upside if price increases significantly in high volatilty scenarios.

These ranges are depicted in the image below, where we consider a quote token ETH and a base token GOV in a very imbalanced ratio.

This strategy sets target prices used as a rebalance trigger. The target price on the GOV token side is set to quickly capture some of the ETH sold to the pool (called $P^{\ast }$ in the figure below).

This ETH is then secured in a full range position via a rebalance of all the positions, which allows to continuously converge to a 50/50 token ratio, which then allows to migrate to a more capital efficient strategy, that we call Flagship strategy.

Flagship strategy

Introduction

The Flagship Strategy is designed to optimize liquidity across different market conditions on AMMs based on Uniswap V3 math. It reacts to price movements, inventory shifts, and market volatility using a flexible system of rules and modes to manage exposure and fee generation.

Implementation

Risk Modes

This strategy runs in one of three risk modes based on volatility:

• 🟢 Low volatility: Most of the liquidity is deployed to maximize trading activity and fee income.
• 🟡 Moderate volatility: Slightly reduced exposure to protect against risk.
• 🔴 High volatility: Only a portion of liquidity is deployed to minimize impermanent loss and risk.

Liquidity Profile

Depending on the mode, the strategy builds liquidity using two or three range types:

• Base Range: A wide range that holds the core liquidity and allows trading of big orders with minimal price impact.
• Bootstrapping Range: A narrower limit-order-like position designed to maintain a 50/50 token ratio.
• Mid Range: A tight position around the current price that provides very deep liquidity and reduces price impact for average orders. This is only present in the low volatility mode.

In the figure below we show a liquidity distribution on a low volatility mode, where the token ratio is 60% GOV and 40% ETH.

Rebalance triggers

• Price Triggers: If the price moves enough in either direction, the strategy redistributes liquidity around the new price. In balanced portfolios (e.g. 50/50 holdings), a standard threshold is used. For imbalanced portfolios, the threshold dynamically adjusts to respond more aggressively or conservatively, depending on how skewed the inventory is.

• Inventory Triggers: If the holdings of the two tokens shift beyond a target ratio (like 75/25), the strategy reacts. It recalculates the liquidity split and redistributes accordingly to guide the pool back toward balance.

• Volatility Triggers: When the market becomes too volatile, the strategy shifts risk modes, pulling back liquidity and widening ranges to reduce risk.

Migration

If you have an Arrakis PALM vault and want to update to the new Arrakis Pro system, contact us.

For now migrations are limited to Uniswap V3 (legacy palm vault) -> Uniswap V4 (pro vault). Because new pro vaults are modular, one could do the migration to Uni V4 and then move to a different module from there.

Migrations, once configured by Arrakis engineers, can be performed seamlessly on the Arrakis Pro UI (via Safe Custom App, for Safe users)

NOTE: because it is a sensitive operations, the migration must be executed within a few minutes of payload generation. Make sure you have signers ready to sign when you are going through migration flow.

Arrakis Modular

Arrakis Modular represents the next evolution of the Arrakis liquidity management smart contract framework, aiming to overcome the limitations of previous versions (V1 and V2).

Check out the Github Repo as well as the documentation here.

Motivation

Arrakis vault contracts have allowed LPs to actively manage or delegate the management of their DEX liquidity positions. However, Arrakis V1 and V2 were purpose-built around Uniswap V3 liquidity. To support alternative venues (e.g. Uniswap V4, Balancer, etc) Arrakis would have to make a completely new standard for each integration from scratch.

Arrakis Modular introduces a universal Meta Vault standard. This modular framework allows Arrakis to create entirely different two-sided LP Vault integrations, which all reuse the same Meta Vault infrastructure and interfaces.

Architecture

Meta Vault: At the heart of the Arrakis Modular system is the concept of a Meta Vault. The Meta Vault creates a unified standard for providing two-sided liquidity to DEXs regardless of the particular features or interfaces of a given DEX.

Modules: Each Meta Vault has the capability to whitelist various modules. A module is essentially a smart contract that establishes an integration with a liquidity-consuming dApp.

Configuration: Each Meta Vaults is configurable by the Vault owner. This design ensures that as new DEXs emerge, Arrakis integration becomes a matter of simply creating and whitelisting a new module compatible with the DEX, and then activating it.

Diagram: Arrakis Modular smart contract system represented visually.

Security: Arrakis Modular from a Security POV.

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 on or across various decentralized exchanges (DEXs) and trading venues.

Public Versus Private

1. Public Meta Vaults: These vaults implement ERC20 and are intended for shared liquidity positions or strategies. They allow for delegated management of liquidity on behalf of multiple participants who mint and burn vault ERC20 token supply by depositing or withdrawing a proportion of vault underlying assets.

2. 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 is tokenized as a fully onchain NFT, as shown below. Only vault owners can withdraw underlying liquidity from a private vault.

Deploying Vaults

The Factory is responsible for deploying new instances of both public and private Meta Vaults. Private vaults can be permissionlessly deployed by any address while public vaults are only deployed and controlled by whitelisted addresses. The Factory contract 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.

Modules also each expose their own custom functions for liquidity management that only the manager of the Meta Vault can call.

Module implementations are whitelisted on public and private registry contracts to ensure security and proper functionality. The vault owner selects which module(s) to attach to their vaults. Each vault has exactly one "active" module and every vault has a setModule function which only the manager can call (to change the "active" module).

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.

Explore module implementations built by Arrakis here. Or check out the modules interfaces here

Vault Configuration

Every Meta Vault has configurable components which can be adjusted by the Vault owner role. The two main configurables are:

1. modules: whitelisting and revoking modules which each define the integration with an underlying liquidity protocol (e.g. HOT AMM module) and also expose certain liquidity management functions that can be invoked by the Arrakis Standard Manager.

2. manager configuration: set on the Arrakis Standard Manager, the vault owner controls the VaultInfo struct including an executor who can call liquidity management functions for this vault from offchain, and safety checks on any liquidity management actions that the executor invokes.

Configuration Management

The Meta Vault owner role has the ability to whitelist modules and configure management parameters on the Arrakis Standard Manager. This means a vault owner can entirely augment where vault liquidity flows, how it behaves, what management functions it exposes, and who can execute management functions.

All Public Vault ownership is immutably behind a multi-day timelock (controlled by the Arrakis DAO) so that LPs are guaranteed to have time to react to any changes in configuration.

Private Vaults Ownership is mapped in the Private Vault NFT contract, and Private Vaults do not enforce a timelock on vault ownership (private vault liquidity providers are intended to be the owner of their private vaults).

Diagram

Security

Arrakis Modular employs a multi-layered security approach that combines proactive monitoring and rapid response capabilities with enforced delays on any critical changes.

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

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

Upgradeability

Most of the Arrakis Modular smart contracts are entirely immutable. However module implementations and the ArrakisStandardManager are behind proxies and may be upgradeable as an initial safety precaution. All upgradeability in Arrakis Modular is behind strict timelocks (controlled by Arrakis DAO) absolutely no instant contract upgrades can be made on the Arrakis Modular system

(NOTE: the modular nature of Arrakis Meta Vaults make them inherently similar to upgradeable proxy patterns. By whitelisting and activating a new module, Arrakis Vault functionality can critically change. This is why Public Vault ownership enforces a timelock.)

Audits

• Audits Page

Price Oracles

All Arrakis Vaults have a concept of a price oracle set by vault owners on the ArrakisStandardManager. These price oracles are used as a third-party check on executor management calls to a vault.

We use our own standard interface for oracle reads and thus we can seamlessly integrate any type of onchain oracle price feed no matter the interfaces/patterns (RedStone, Chainlink, Uni V3 TWAP, etc) -- just by defining a simple Oracle Wrapper smart contract.

To accelerate the integration of safe public and private Meta Vaults for newer tokens that may not already have performant oracle feeds onchain, we refer clients to our oracle partner RedStone.

Methodology

Arrakis implements a standard oracle interface that must be followed:

interface IOracleWrapper {
    /// @notice function used to get price0.
    /// @return price0 price of token0/token1.
    function getPrice0() external view returns (uint256 price0);

    /// @notice function used to get price1.
    /// @return price1 price of token1/token0.
    function getPrice1() external view returns (uint256 price1);
}

Any smart contract that utilizes this interface can function as an oracle on the Arrakis standard manager. This interface is consumed during ArrakisStandardManager.rebalance here:

        uint256 price0 = info.oracle.getPrice0();

        uint256 vaultInToken1BeforeRebalance = FullMath.mulDiv(
            amount0, price0, 10 ** token0Decimals
        ) + amount1;

we store vaultInToken1BeforeRebalance and then compare it to the value after rebalance. Further checks can be implemented at the module level with oracle price feeds thanks to this call here:

    module.validateRebalance(info.oracle, info.maxDeviation);

Deployments

Arrakis Modular Smart Contracts are deployed on Mainnet, Base, Arbitrum, Optimism, Polygon, Ink, Unichain and Sepolia. They are deployed using CREATE3, and share addresses among all the networks.

* Not available on Sepolia

** Only available on Base

Technical reference

Welcome to the smart contract technical reference of the Arrakis Modular smart contract framework. See Here for the github repository.

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

abstracts/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
• Arrakis Standard Manager

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);

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;

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

Abstracts

• Uniswap V4 Standard Module
• PancakeSwap Infinity Standard Module
• Valantis HOT Module

Contracts

• Aerodrome Standard Module Private
• Uniswap V4 Standard Module Private
• PancakeSwap Infinity Standard Module Private
• Valantis HOT Module Public

UniV4StandardModule

Git Source

Inherits: ReentrancyGuardUpgradeable, PausableUpgradeable, IArrakisLPModule, IArrakisLPModuleID, IUniV4StandardModule, IUnlockCallback

this module can only set uni v4 pool that have generic hook, that don't require specific action to become liquidity provider.

due to native coin standard difference between uni V4 and arrakis, we are assuming that all inputed amounts are using arrakis vault token0/token1 as reference. Internal logic of UniV4StandardModule will handle the conversion or use the poolKey to interact with the poolManager.

State Variables

poolManager

function used to get the uniswap v4 pool manager.

IPoolManager public immutable poolManager;

_guardian

address internal immutable _guardian;

metaVault

module's metaVault as IArrakisMetaVault.

IArrakisMetaVault public metaVault;

token0

module's token0 as IERC20Metadata.

IERC20Metadata public token0;

token1

module's token1 as IERC20Metadata.

IERC20Metadata public token1;

isInversed

boolean to know if the poolKey's currencies pair are inversed.

bool public isInversed;

managerFeePIPS

manager fees share.

uint256 public managerFeePIPS;

oracle

oracle that will be used to proctect rebalances against attacks.

IOracleWrapper public oracle;

maxSlippage

max slippage that can occur during swap rebalance.

uint24 public maxSlippage;

poolKey

pool's key of the module.

PoolKey public poolKey;

ethWithdrawers

list of allowed addresses to withdraw eth.

mapping(address => uint256) public ethWithdrawers;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_ranges

Range[] internal _ranges;

_activeRanges

mapping(bytes32 => bool) internal _activeRanges;

Functions

onlyManager

modifier onlyManager();

onlyMetaVault

modifier onlyMetaVault();

onlyGuardian

modifier onlyGuardian();

constructor

constructor(address poolManager_, address guardian_);

pause

function used to pause the module.

only callable by guardian

function pause() external whenNotPaused onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external whenPaused onlyGuardian;

initialize

initialize function to delegate call onced the beacon proxy is deployed, for initializing the uniswap v4 standard module.

function initialize(
    uint256 init0_,
    uint256 init1_,
    bool isInversed_,
    PoolKey calldata poolKey_,
    IOracleWrapper oracle_,
    uint24 maxSlippage_,
    address metaVault_
) external initializer;

Parameters

initializePosition

function used to initialize the module when a module switch happen

check if the pool is initialized.

function initializePosition(
    bytes calldata
) external virtual onlyMetaVault;

withdrawEth

left over will sit on the module.

function withdrawEth(
    uint256 amount_
) external nonReentrant whenNotPaused;

approve

function approve(
    address spender_,
    uint256 amount0_,
    uint256 amount1_
) external nonReentrant whenNotPaused;

setPool

function used to set the pool for the module.

function setPool(
    PoolKey calldata poolKey_,
    LiquidityRange[] calldata liquidityRanges_,
    SwapPayload calldata swapPayload_,
    uint256 minBurn0_,
    uint256 minBurn1_,
    uint256 minDeposit0_,
    uint256 minDeposit1_
) external onlyManager nonReentrant whenNotPaused;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

check if the pool is initialized.

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

Parameters

Returns

rebalance

function used to rebalance the inventory of the module.

function rebalance(
    LiquidityRange[] memory liquidityRanges_,
    SwapPayload memory swapPayload_,
    uint256 minBurn0_,
    uint256 minBurn1_,
    uint256 minDeposit0_,
    uint256 minDeposit1_
)
    public
    onlyManager
    nonReentrant
    whenNotPaused
    returns (
        uint256 amount0Minted,
        uint256 amount1Minted,
        uint256 amount0Burned,
        uint256 amount1Burned
    );

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

default swapPayload, no swap happens here. swapPayload will be empty. And will use it to do rebalance and collect fees.

function setManagerFeePIPS(
    uint256 newFeePIPS_
) external onlyManager whenNotPaused;

Parameters

receive

receive() external payable;

guardian

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

function guardian() external view returns (address);

Returns

getRanges

function used to get the list of active ranges.

function getRanges() external view returns (Range[] memory ranges);

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

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 managerFee0);

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 managerFee1);

Returns

_unlockCallback

function _unlockCallback(
    Action action_,
    bytes memory data_
) internal returns (bytes memory);

_internalRebalance

function _internalRebalance(
    LiquidityRange[] memory liquidityRanges_,
    SwapPayload memory swapPayload_
)
    internal
    returns (
        uint256 amount0Minted,
        uint256 amount1Minted,
        uint256 amount0Burned,
        uint256 amount1Burned
    );

Enums

Action

enum Action {
    WITHDRAW,
    REBALANCE,
    DEPOSIT_FUND
}

PancakeSwapV4StandardModule

Git Source

Inherits: ReentrancyGuardUpgradeable, PausableUpgradeable, IArrakisLPModule, IArrakisLPModuleID, IPancakeSwapV4StandardModule, ILockCallback

this module can set pancakeswap v4 pool that have a generic hook, that don't require specific action to become liquidity provider.

due to native coin standard difference between pancakeswap and arrakis, we are assuming that all inputed amounts are using arrakis vault token0/token1 as reference. Internal logic of PancakeSwapV4StandardModule will handle the conversion or use the poolKey to interact with the poolManager.

State Variables

poolManager

ICLPoolManager public immutable poolManager;

vault

IVault public immutable vault;

distributor

IDistributor public immutable distributor;

collector

address public immutable collector;

_guardian

address internal immutable _guardian;

metaVault

module's metaVault as IArrakisMetaVault.

IArrakisMetaVault public metaVault;

token0

module's token0 as IERC20Metadata.

IERC20Metadata public token0;

token1

module's token1 as IERC20Metadata.

IERC20Metadata public token1;

isInversed

boolean to know if the poolKey's currencies pair are inversed.

bool public isInversed;

managerFeePIPS

manager fees share.

uint256 public managerFeePIPS;

oracle

oracle that will be used to proctect rebalances against attacks.

IOracleWrapper public oracle;

maxSlippage

max slippage that can occur during swap rebalance.

uint24 public maxSlippage;

poolKey

pool's key of the module.

PoolKey public poolKey;

ethWithdrawers

list of allowed addresses to withdraw eth.

mapping(address => uint256) public ethWithdrawers;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_ranges

Range[] internal _ranges;

_activeRanges

mapping(bytes32 => bool) internal _activeRanges;

Functions

onlyManager

modifier onlyManager();

onlyMetaVault

modifier onlyMetaVault();

onlyGuardian

modifier onlyGuardian();

onlyMetaVaultOwner

modifier onlyMetaVaultOwner();

constructor

constructor(
    address poolManager_,
    address guardian_,
    address vault_,
    address distributor_,
    address collector_
);

pause

function used to pause the module.

only callable by guardian

function pause() external whenNotPaused onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external whenPaused onlyGuardian;

initialize

initialize function to delegate call onced the beacon proxy is deployed, for initializing the uniswap v4 standard module.

function initialize(
    uint256 init0_,
    uint256 init1_,
    bool isInversed_,
    PoolKey calldata poolKey_,
    IOracleWrapper oracle_,
    uint24 maxSlippage_,
    address metaVault_
) external initializer;

Parameters

initializePosition

function used to initialize the module when a module switch happen

check if the pool is initialized.

function initializePosition(
    bytes calldata
) external virtual onlyMetaVault;

withdrawEth

left over will sit on the module.

function withdrawEth(
    uint256 amount_
) external nonReentrant whenNotPaused;

approve

function approve(
    address spender_,
    address[] calldata tokens_,
    uint256[] calldata amounts_
) external nonReentrant whenNotPaused onlyMetaVaultOwner;

setPool

function used to set the pool for the module.

function setPool(
    PoolKey calldata poolKey_,
    LiquidityRange[] calldata liquidityRanges_,
    SwapPayload calldata swapPayload_,
    uint256 minBurn0_,
    uint256 minBurn1_,
    uint256 minDeposit0_,
    uint256 minDeposit1_
) external onlyManager nonReentrant whenNotPaused;

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

rebalance

function used to rebalance the inventory of the module.

function rebalance(
    LiquidityRange[] memory liquidityRanges_,
    SwapPayload memory swapPayload_,
    uint256 minBurn0_,
    uint256 minBurn1_,
    uint256 minDeposit0_,
    uint256 minDeposit1_
)
    public
    onlyManager
    nonReentrant
    whenNotPaused
    returns (
        uint256 amount0Minted,
        uint256 amount1Minted,
        uint256 amount0Burned,
        uint256 amount1Burned
    );

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

default swapPayload, no swap happens here. swapPayload will be empty. And will use it to do rebalance and collect fees.

function setManagerFeePIPS(
    uint256 newFeePIPS_
) external onlyManager whenNotPaused;

Parameters

receive

receive() external payable;

guardian

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

function guardian() external view returns (address);

Returns

getRanges

function used to get the list of active ranges.

function getRanges() external view returns (Range[] memory ranges);

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

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 managerFee0);

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 managerFee1);

Returns

_lockAcquired

function _lockAcquired(
    Action action_,
    bytes memory data_
) internal returns (bytes memory);

_internalRebalance

function _internalRebalance(
    LiquidityRange[] memory liquidityRanges_,
    SwapPayload memory swapPayload_
)
    internal
    returns (
        uint256 amount0Minted,
        uint256 amount1Minted,
        uint256 amount0Burned,
        uint256 amount1Burned
    );

Enums

Action

enum Action {
    WITHDRAW,
    REBALANCE,
    DEPOSIT_FUND
}

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;

AerodromeStandardModulePrivate

Git Source

Inherits: IArrakisLPModule, IArrakisLPModulePrivate, IAerodromeStandardModulePrivate, IArrakisLPModuleID, IERC721Receiver, PausableUpgradeable, ReentrancyGuardUpgradeable

State Variables

id

function used to get module id.

id = keccak256(abi.encode("AerodromeStandardModulePrivate"))

bytes32 public constant id =
    0x491defc0794897991a8e5e9fa49dcbed24fe84ee079750b1db3f4df77fb17cb5;

AERO

function used to get aero token address.

address public immutable AERO;

_guardian

address internal immutable _guardian;

nftPositionManager

function used to get the NonFungiblePositionManager of aerodrome.

INonfungiblePositionManager public immutable nftPositionManager;

factory

function used to get the factory of aerodrome.

IUniswapV3Factory public immutable factory;

voter

function used to get the voter of aerodrome.

IVoter public immutable voter;

metaVault

function used to get metaVault as IArrakisMetaVault.

IArrakisMetaVault public metaVault;

token0

function used to get token0 as IERC20Metadata.

IERC20Metadata public token0;

token1

function used to get token1 as IERC20Metadata.

IERC20Metadata public token1;

oracle

function used to get the oracle that will be used to proctect rebalances.

IOracleWrapper public oracle;

managerFeePIPS

function used to get manager fees.

uint256 public managerFeePIPS;

maxSlippage

function used to get the maximum slippage.

uint24 public maxSlippage;

aeroReceiver

function used to get aero token receiver.

address public aeroReceiver;

pool

function used to get aero pool the module is interacting with.

address public pool;

gauge

function used to get aero gauge associated to pool the module is interacting with.

address public gauge;

_tokenIds

EnumerableSet.UintSet internal _tokenIds;

_aeroManagerBalance

uint256 internal _aeroManagerBalance;

Functions

onlyManager

modifier onlyManager();

onlyMetaVault

modifier onlyMetaVault();

onlyGuardian

modifier onlyGuardian();

onlyMetaVaultOwner

modifier onlyMetaVaultOwner();

constructor

constructor(
    address nftPositionManager_,
    address factory_,
    address voter_,
    address guardian_
);

onERC721Received

Whenever an {IERC721} tokenId token is transferred to this contract via {IERC721-safeTransferFrom} by operator from from, this function is called. It must return its Solidity selector to confirm the token transfer. If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. The selector can be obtained in Solidity with IERC721Receiver.onERC721Received.selector.

function onERC721Received(
    address,
    address,
    uint256,
    bytes calldata
) external returns (bytes4);

pause

function used to pause the module.

only callable by guardian

function pause() external whenNotPaused onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external whenPaused onlyGuardian;

initialize

initialize function to delegate call onced the beacon proxy is deployed, for initializing the aerodrome module.

function initialize(
    IOracleWrapper oracle_,
    uint24 maxSlippage_,
    address aeroReceiver_,
    int24 tickSpacing_,
    address metaVault_
) external initializer;

Parameters

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(
    bytes calldata data_
) external;

Parameters

approve

function used to approve a spender to use the left over of the module.

left over will sit on the module.

function approve(
    address spender_,
    uint256 amount0_,
    uint256 amount1_
) external nonReentrant whenNotPaused onlyMetaVaultOwner;

Parameters

fund

deposit function for private vault.

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

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

claimRewards

function used by user to claim the aero rewards.

decrease nft position or burn it.

function claimRewards(
    address receiver_
) external onlyMetaVaultOwner nonReentrant whenNotPaused;

Parameters

setReceiver

function used to set the receiver of aero rewards.

function setReceiver(
    address newReceiver_
) external whenNotPaused;

Parameters

claimManager

function used by executor to claim the manager aero rewards.

function claimManager() public nonReentrant whenNotPaused;

rebalance

function used to rebalance the inventory of the module.

function rebalance(
    RebalanceParams calldata params_
) external nonReentrant whenNotPaused onlyManager;

Parameters

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(
    uint256 newFeePIPS_
) external onlyManager whenNotPaused;

Parameters

guardian

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

function guardian() external view returns (address);

Returns

tokenIds

function used to get the list of tokenIds of non fungible position.

function tokenIds() external view returns (uint256[] memory);

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

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 managerFee0);

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 managerFee1);

Returns

aeroManagerBalance

function used to get aero balance due to manager.

function aeroManagerBalance() external view returns (uint256);

_decreaseLiquidity

function _decreaseLiquidity(
    ModifyPosition memory modifyPosition_,
    uint160 sqrtPriceX96_
)
    internal
    returns (
        uint256 amount0ToSend,
        uint256 amount1ToSend,
        uint256 aeroAmountCollected
    );

_increaseLiquidity

function _increaseLiquidity(
    ModifyPosition memory modifyPosition_,
    uint160 sqrtPriceX96_
)
    internal
    returns (
        uint256 amount0Sent,
        uint256 amount1Sent,
        uint256 aeroAmountCollected
    );

_unstake

function _unstake(
    uint256 tokenId_
)
    internal
    returns (
        uint256 aeroAmountCollected,
        address _gauge,
        uint128 liquidity
    );

_mint

function _mint(
    INonfungiblePositionManager.MintParams calldata params_,
    address token0_,
    address token1_
) internal returns (uint256 amount0, uint256 amount1);

_checkMinReturn

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

_principal

function _principal(
    uint256 tokenId_,
    uint160 sqrtRatioX96_
) internal view returns (uint256 amount0, uint256 amount1);

_getPosition

trick to workaround stack too deep.

function _getPosition(
    uint256 tokenId_
)
    internal
    view
    returns (int24 tickLower, int24 tickUpper, uint128 liquidity);

UniV4StandardModulePrivate

Git Source

Inherits: UniV4StandardModule, IArrakisLPModulePrivate

this module can only set uni v4 pool that have generic hook, that don't require specific action to become liquidity provider.

State Variables

id

id = keccak256(abi.encode("UniV4StandardModulePrivate"))

bytes32 public constant id =
    0xae9c8e22b1f7ab201e144775cd6f848c3c1b0a82315571de8c67ce32ca9a7d44;

Functions

constructor

constructor(
    address poolManager_,
    address guardian_,
    address distributor_,
    address collector_
)
    UniV4StandardModule(poolManager_, guardian_, distributor_, collector_);

fund

fund function for private vault.

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

Parameters

unlockCallback

Called by the pool manager on msg.sender when a lock is acquired

function unlockCallback(
    bytes calldata data_
) public virtual returns (bytes memory);

Parameters

Returns

_fund

use data to do specific action.

function _fund(
    address depositor_,
    uint256 amount0_,
    uint256 amount1_
) internal;

PancakeSwapV4StandardModulePrivate

Git Source

Inherits: PancakeSwapV4StandardModule, IArrakisLPModulePrivate

State Variables

id

id = keccak256(abi.encode("PancakeSwapV4StandardModulePrivate"))

bytes32 public constant id =
    0x7cec99d521e59378e389a879513f6373dd58e86a0c1422fa01195032b7071950;

Functions

constructor

constructor(
    address poolManager_,
    address guardian_,
    address vault_,
    address distributor_,
    address collector_
)
    PancakeSwapV4StandardModule(
        poolManager_,
        guardian_,
        vault_,
        distributor_,
        collector_
    );

fund

fund function for private vault.

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

Parameters

_fund

function _fund(
    address depositor_,
    uint256 amount0_,
    uint256 amount1_
) internal;

lockAcquired

function lockAcquired(
    bytes calldata data_
) public virtual returns (bytes memory);

ValantisModulePublic

Git Source

Inherits: ValantisModule, IArrakisLPModulePublic

State Variables

notFirstDeposit

bool public notFirstDeposit;

Functions

constructor

constructor(
    address guardian_
) ValantisModule(guardian_);

deposit

deposit function for public vault.

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

Parameters

Returns

withdraw

function used by metaVault to withdraw tokens from the strategy.

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

Parameters

Returns

initializePosition

function initializePosition(
    bytes calldata data_
) external override onlyMetaVault;

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
    );

ArrakisPrivateVaultRouter

Git Source

Inherits: IArrakisPrivateVaultRouter, ReentrancyGuard, Ownable, Pausable

State Variables

nativeToken

address of the native token.

address public immutable nativeToken;

permit2

permit2 contract address.

IPermit2 public immutable permit2;

factory

arrakis meta vault factory contract address.

IArrakisMetaVaultFactory public immutable factory;

weth

wrapped eth contract address.

IWETH9 public immutable weth;

swapper

swap executor contract address.

IPrivateRouterSwapExecutor public swapper;

Functions

onlyPrivateVault

modifier onlyPrivateVault(
    address vault_
);

onlyDepositor

modifier onlyDepositor(
    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 whenNotPaused onlyOwner;

unpause

function used to unpause the router.

only callable by owner

function unpause() external whenPaused onlyOwner;

updateSwapExecutor

function updateSwapExecutor(
    address swapper_
) external whenNotPaused onlyOwner;

addLiquidity

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

function addLiquidity(
    AddLiquidityData memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.vault)
    onlyDepositor(params_.vault);

Parameters

swapAndAddLiquidity

swapAndAddLiquidity transfer tokens to and calls RouterSwapExecutor

function swapAndAddLiquidity(
    SwapAndAddData memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.addData.vault)
    onlyDepositor(params_.addData.vault)
    returns (uint256 amount0Diff, uint256 amount1Diff);

Parameters

Returns

addLiquidityPermit2

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

function addLiquidityPermit2(
    AddLiquidityPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.addData.vault)
    onlyDepositor(params_.addData.vault);

Parameters

swapAndAddLiquidityPermit2

swapAndAddLiquidityPermit2 transfer tokens to and calls RouterSwapExecutor

function swapAndAddLiquidityPermit2(
    SwapAndAddPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.swapAndAddData.addData.vault)
    onlyDepositor(params_.swapAndAddData.addData.vault)
    returns (uint256 amount0Diff, uint256 amount1Diff);

Parameters

Returns

wrapAndAddLiquidity

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

function wrapAndAddLiquidity(
    AddLiquidityData memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.vault)
    onlyDepositor(params_.vault);

Parameters

wrapAndSwapAndAddLiquidity

wrapAndSwapAndAddLiquidity wrap eth and transfer tokens to and calls RouterSwapExecutor

function wrapAndSwapAndAddLiquidity(
    SwapAndAddData memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.addData.vault)
    onlyDepositor(params_.addData.vault)
    returns (uint256 amount0Diff, uint256 amount1Diff);

Parameters

Returns

wrapAndAddLiquidityPermit2

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

function wrapAndAddLiquidityPermit2(
    AddLiquidityPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.addData.vault)
    onlyDepositor(params_.addData.vault);

Parameters

wrapAndSwapAndAddLiquidityPermit2

wrapAndSwapAndAddLiquidityPermit2 wrap eth and transfer tokens to and calls RouterSwapExecutor

function wrapAndSwapAndAddLiquidityPermit2(
    SwapAndAddPermit2Data memory params_
)
    external
    payable
    nonReentrant
    whenNotPaused
    onlyPrivateVault(params_.swapAndAddData.addData.vault)
    onlyDepositor(params_.swapAndAddData.addData.vault)
    returns (uint256 amount0Diff, uint256 amount1Diff);

Parameters

Returns

receive

receive() external payable;

_addLiquidity

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

_swapAndAddLiquidity

function _swapAndAddLiquidity(
    SwapAndAddData memory params_,
    address token0_,
    address token1_
) internal returns (uint256 amount0Diff, uint256 amount1Diff);

_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;

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

• Guardian
• Pauser
• TimeLock

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
• UniV4StandardModule
• 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;

PancakeSwapV4StandardModule

Git Source

Inherits: ReentrancyGuardUpgradeable, PausableUpgradeable, IArrakisLPModule, IArrakisLPModuleID, IPancakeSwapV4StandardModule, ILockCallback

this module can set pancakeswap v4 pool that have a generic hook, that don't require specific action to become liquidity provider.

due to native coin standard difference between pancakeswap and arrakis, we are assuming that all inputed amounts are using arrakis vault token0/token1 as reference. Internal logic of PancakeSwapV4StandardModule will handle the conversion or use the poolKey to interact with the poolManager.

State Variables

poolManager

ICLPoolManager public immutable poolManager;

vault

IVault public immutable vault;

distributor

IDistributor public immutable distributor;

collector

address public immutable collector;

_guardian

address internal immutable _guardian;

metaVault

module's metaVault as IArrakisMetaVault.

IArrakisMetaVault public metaVault;

token0