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:

• Arrakis Protocol
• Brand New: HOT AMM
• Arrakis Pro

Or jump straight into:

• 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, the new HOT AMM Public Vault is formed by the following components:

• Arrakis Quoter and other offchain market making components.
• Arrakis Modular (smart contract framework) Public Vaults.
• A new custom Valantis Sovereign Pool (as the 1st DEX integration).

HOT AMM

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

To learn more, refer to this HOT AMM: Concepts page.

Just want to deposit? Here's our New User Interface

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

Flagship Public Vault using HOT AMM

Our flagship WETH/USDC Arrakis Modular Public Vault on Ethereum Mainnet deploys it's funds into a HOT AMM liquidity pool (details).

This public vault offering is similar to LPing on a traditional AMM, but has a few advanced features under the hood:

• actively managed concentrated liquidity rebalancing (via the Arrakis Public Vault manager role)
• intents-based Quoter activity (via the underlying HOT AMM QuoteSigner role)

Thanks to these roles (and proper strategies for their activity), LPs can passively make WETH/USDC markets in a way that is competitive with the most sophisticated Private Market Makers onchain.

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.

Problem Statement

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

Arrakis Pro supports token issuers by:

• Supporting token launches
• Bootstraping liquidity
• Ongoing inventory management

Benefits

Protocols and DAOs can benefit from the following:

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

Solution

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

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

Get in Touch

Arrakis is trusted by MakerDAO, Lido, EtherFi, Across, Stargate, Gnosis, 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 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

Quickstart: Public Vaults

To make the deposit process safe and simple we created the Arrakis Public Vault Router. This contract is in charge of getting the right amounts and tokens to deposit, as well as containing convenient functions with the ability to wrap assets and swap atomically before deposit. It also integrates the Permit 2 standard for gassless approvals.

Add Liquidity

The following provides a step-by-step explanation of depositing liquidity into an Arrakis Public Vault via the Router.

1. Identify the Meta Vault associated to the pair you want to participate in. See for example here for a list of Public Vaults.

2. Next step is use the Router to determine how many of each tokens you expect to need to join the Meta Vault.

   • Use getMintAmounts to determine the extact amounts of token0 and token1 you expect to deposit, given the maximum of each token you'd like to provide.

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

   • Calling the standard ERC20 Approve (approve <router> to spend)
   • Set up Permit2 data and signature

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

   • If you set up ERC20 approvals:

     • Call addLiquidity to deposit both tokens to the vault.
     • If you have ETH and want to deposit into a pool with WETH as one of its tokens, you can also call wrapAndAddLiquidity.
     • If you want to synchronously perform a swap before adding liquidity you can call swapAndAddLiquidity or wrapAndSwapAndAddLiquidity (if you want to use send native ETH instead of WETH for a swap-and-deposit interaction)

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

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

Remove Liquidity

Removing Liquidity from an Arakis Public Vault that you hold LP tokens of is easy.

Simply call the burn directly on an Arrakis Meta Vault Public contract to burn amount of LP tokens that you hold and remit two-sided underlying (token0 and token1) to your receiver address of choice.

Public Vault List

Just want to deposit? Here's our New User Interface

Ethereum Mainnet

WETH/USDC Vault

This is the first and flagship Arrakis Modular Public Vault.

• Network: Ethereum Mainnet
• Vault Address: 0xf790870ccF6aE66DdC69f68e6d05d446f1a6ad83
• Type: ERC20
• Symbol: ARRAKIS
• Active Module: HOT AMM
• Whitelisted Modules: HOT AMM, Bunker (safety module)
• Vault Owner (Timelock): 0xCFaD8B6981Da1c734352Bd31618040C23FE99117
• Vault Timelock Admin: 0x5108EF86cF493905BcD35A3736e4B46DeCD7de58 (Arrakis Multisig)

Management Configuration:

• Vault Executor: 0x030DE9fd3ca63AB012f4E22dB595b66C812c8525 (HOTExecutor)
• Price Oracle: 0xF23d83Da92844C53aD57e6031c231dC93eC4eE80 (Wrapped Chainlink feeds)
• Cooldown Period: 60 seconds
• Max Oracle Deviation: 2%
• Max Swap Slippage: 2%
• Manager Fee (on Swap Fees Earned): 1%

HOT AMM pool WETH/USDC Config:

• QuoteSigner: 0x498c8a1a179b5D1D4Ff64bC90Cf3224a3478765C (controlled by Arrakis)
• HOT Manager: 0xAf6f9640092cB1236E5DB6E517576355b6C40b7f (timelocked)
• Price Oracle: Chainlink
• Max HOT Swaps Per Block: 3
• Max HOT Swap Oracle Deviation: 3.5%

Read more about the HOT AMM Quoter and the Vault Manager Functions which both perform actions that help power this Public Vault.

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, Arbitrum, Base and Sepolia. They are deployed using CREATE3, and share addresses among all the networks.

* Not available on Sepolia

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

• Valantis Module

ValantisModule

Git Source

Inherits: IArrakisLPModule, IValantisHOTModule, PausableUpgradeable, ReentrancyGuardUpgradeable

BeaconProxy be careful for changing implementation with upgrade.

State Variables

metaVault

IArrakisMetaVault public metaVault;

pool

ISovereignPool public pool;

alm

IHOT public alm;

token0

IERC20Metadata public token0;

token1

IERC20Metadata public token1;

maxSlippage

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

uint24 public maxSlippage;

oracle

IOracleWrapper public oracle;

_guardian

address internal immutable _guardian;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_managerFeePIPS

uint256 internal _managerFeePIPS;

Functions

onlyMetaVault

modifier onlyMetaVault();

onlyManager

modifier onlyManager();

onlyGuardian

modifier onlyGuardian();

constructor

constructor(address guardian_);

initialize

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

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

Parameters

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_)
    external
    virtual
    onlyMetaVault;

Parameters

pause

function used to pause the module.

only callable by guardian

function pause() external onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external onlyGuardian;

setALMAndManagerFees

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

function setALMAndManagerFees(
    address alm_,
    address oracle_
) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

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

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_)
    external
    whenNotPaused
    onlyManager;

Parameters

setPriceBounds

fucntion used to set range on valantis AMM

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

Parameters

swap

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

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

Parameters

managerBalance0

function used to get manager token0 balance.

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

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

Returns

managerBalance1

function used to get manager token1 balance.

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

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

Returns

validateRebalance

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

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

Parameters

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

getInits

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

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

Returns

totalUnderlying

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

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

Returns

totalUnderlyingAtPrice

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

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

Parameters

Returns

guardian

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

function guardian() external view returns (address);

Returns

_initializePosition

function _initializePosition() internal;

_checkMinReturn

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

Routers

Content

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

ArrakisPublicVaultRouter

Git Source

Inherits: IArrakisPublicVaultRouter, ReentrancyGuard, Ownable, Pausable

State Variables

nativeToken

address public immutable nativeToken;

permit2

IPermit2 public immutable permit2;

factory

IArrakisMetaVaultFactory public immutable factory;

weth

IWETH9 public immutable weth;

swapper

IRouterSwapExecutor public swapper;

Functions

onlyPublicVault

modifier onlyPublicVault(address vault_);

constructor

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

pause

function used to pause the router.

only callable by owner

function pause() external onlyOwner;

unpause

function used to unpause the router.

only callable by owner

function unpause() external onlyOwner;

updateSwapExecutor

function updateSwapExecutor(address swapper_)
    external
    whenNotPaused
    onlyOwner;

addLiquidity

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

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

Parameters

Returns

swapAndAddLiquidity

swapAndAddLiquidity transfer tokens to and calls RouterSwapExecutor

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

Parameters

Returns

removeLiquidity

removeLiquidity removes liquidity from vault and burns LP tokens

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

Parameters

Returns

addLiquidityPermit2

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

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

Parameters

Returns

swapAndAddLiquidityPermit2

swapAndAddLiquidityPermit2 transfer tokens to and calls RouterSwapExecutor

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

Parameters

Returns

removeLiquidityPermit2

removeLiquidityPermit2 removes liquidity from vault and burns LP tokens

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

Parameters

Returns

wrapAndAddLiquidity

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

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

Parameters

Returns

wrapAndSwapAndAddLiquidity

wrapAndSwapAndAddLiquidity wrap eth and transfer tokens to and calls RouterSwapExecutor

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

Parameters

Returns

wrapAndAddLiquidityPermit2

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

hack to get rid of stack too depth

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

Parameters

Returns

wrapAndSwapAndAddLiquidityPermit2

wrapAndSwapAndAddLiquidityPermit2 wrap eth and transfer tokens to and calls RouterSwapExecutor

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

Parameters

Returns

receive

hack to get rid of stack too depth

receive() external payable;

getMintAmounts

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

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

Parameters

Returns

_addLiquidity

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

_swapAndAddLiquidity

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

_swapAndAddLiquiditySendBackLeftOver

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

_removeLiquidity

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

_permit2AddLengthOne

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

_permit2AddLengthOneOrTwo

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

_permit2Add

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

_permit2SwapAndAddLengthOne

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

_permit2SwapAndAddLengthOneOrTwo

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

_permit2SwapAndAdd

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

_getMintAmounts

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

RouterSwapExecutor

Git Source

Inherits: IRouterSwapExecutor

State Variables

router

address public immutable router;

nativeToken

address public immutable nativeToken;

Functions

onlyRouter

modifier onlyRouter();

constructor

constructor(address router_, address nativeToken_);

swap

function used to swap tokens.

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

Parameters

Returns

receive

receive() external payable;

RouterSwapResolver

Git Source

Inherits: IRouterSwapResolver

State Variables

router

IArrakisPublicVaultRouter public immutable router;

Functions

constructor

constructor(address router_);

calculateSwapAmount

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

_getUnderlyingOrLiquidity

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

Roter Structs

Content

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

AddLiquidityData

Git Source

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

Variables

AddLiquidityPermit2Data

Git Source

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

Variables

RemoveLiquidityData

Git Source

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

Variables

RemoveLiquidityPermit2Data

Git Source

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

Variables

SwapAndAddData

Git Source

struct SwapAndAddData {
    SwapData swapData;
    AddLiquidityData addData;
}

Variables

SwapAndAddPermit2Data

Git Source

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

SwapData

Git Source

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

Variables

Admin and Security

Content

• 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
• ValantisModule

ArrakisMetaVault

Git Source

Inherits: IArrakisMetaVault, ReentrancyGuard, Initializable

State Variables

moduleRegistry

address public immutable moduleRegistry;

token0

address public immutable token0;

token1

address public immutable token1;

manager

address public immutable manager;

module

IArrakisLPModule public module;

_whitelistedModules

EnumerableSet.AddressSet internal _whitelistedModules;

Functions

onlyOwnerCustom

modifier onlyOwnerCustom();

onlyManager

modifier onlyManager();

constructor

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

initialize

function initialize(address module_) external initializer;

setModule

function used to set module

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

Parameters

whitelistModules

function used to whitelist modules that can used by manager.

we transfer here all tokens to the new module.

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

Parameters

blacklistModules

function used to blacklist modules that can used by manager.

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

Parameters

whitelistedModules

function used to get the list of modules whitelisted.

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

Returns

getInits

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

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

Returns

totalUnderlying

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

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

Returns

totalUnderlyingAtPrice

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

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

Parameters

Returns

_withdraw

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

_withdrawManagerBalance

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

_call

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

_onlyOwnerCheck

function _onlyOwnerCheck() internal view virtual;

ModuleRegistry

Git Source

Inherits: IModuleRegistry, Ownable, Initializable

State Variables

factory

IArrakisMetaVaultFactory public factory;

admin

should be a timelock contract.

address public immutable admin;

_guardian

address internal immutable _guardian;

_beacons

EnumerableSet.AddressSet internal _beacons;

Functions

constructor

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

initialize

function used to initialize module registry.

function initialize(address factory_) external initializer;

Parameters

beacons

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

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

Returns

beaconsContains

function to know if the beacons enumerableSet contain beacon_

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

Parameters

guardian

function used to get the guardian address of arrakis protocol.

function guardian() external view returns (address);

Returns

whitelistBeacons

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

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

Parameters

blacklistBeacons

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

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

Parameters

_createModule

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

_checkVaultNotAddressZero

function _checkVaultNotAddressZero(address vault_) internal pure;

ValantisModule

Git Source

Inherits: IArrakisLPModule, IValantisHOTModule, PausableUpgradeable, ReentrancyGuardUpgradeable

BeaconProxy be careful for changing implementation with upgrade.

State Variables

metaVault

IArrakisMetaVault public metaVault;

pool

ISovereignPool public pool;

alm

IHOT public alm;

token0

IERC20Metadata public token0;

token1

IERC20Metadata public token1;

maxSlippage

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

uint24 public maxSlippage;

oracle

IOracleWrapper public oracle;

_guardian

address internal immutable _guardian;

_init0

uint256 internal _init0;

_init1

uint256 internal _init1;

_managerFeePIPS

uint256 internal _managerFeePIPS;

Functions

onlyMetaVault

modifier onlyMetaVault();

onlyManager

modifier onlyManager();

onlyGuardian

modifier onlyGuardian();

constructor

constructor(address guardian_);

initialize

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

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

Parameters

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_)
    external
    virtual
    onlyMetaVault;

Parameters

pause

function used to pause the module.

only callable by guardian

function pause() external onlyGuardian;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external onlyGuardian;

setALMAndManagerFees

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

function setALMAndManagerFees(
    address alm_,
    address oracle_
) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

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

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_)
    external
    whenNotPaused
    onlyManager;

Parameters

setPriceBounds

fucntion used to set range on valantis AMM

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

Parameters

swap

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

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

Parameters

managerBalance0

function used to get manager token0 balance.

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

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

Returns

managerBalance1

function used to get manager token1 balance.

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

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

Returns

validateRebalance

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

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

Parameters

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

getInits

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

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

Returns

totalUnderlying

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

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

Returns

totalUnderlyingAtPrice

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

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

Parameters

Returns

guardian

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

function guardian() external view returns (address);

Returns

_initializePosition

function _initializePosition() internal;

_checkMinReturn

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

Contents

• CArrakis constants

Constants

Git Source

MINIMUM_LIQUIDITY

uint256 constant MINIMUM_LIQUIDITY = 10 ** 3;

BASE

uint256 constant BASE = 1e18;

PIPS

uint24 constant PIPS = 1_000_000;

TEN_PERCENT

uint24 constant TEN_PERCENT = 100_000;

WEEK

uint256 constant WEEK = 604_800;

NATIVE_COIN

address constant NATIVE_COIN =
    0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

NATIVE_COIN_DECIMALS

uint8 constant NATIVE_COIN_DECIMALS = 18;

Contents

• ArrakisPrivateHook

ArrakisPrivateHook

Git Source

Inherits: IHooks, IArrakisPrivateHook

State Variables

module

address public immutable module;

poolManager

address public immutable poolManager;

vault

address public immutable vault;

manager

address public immutable manager;

fee

uint24 public fee;

Functions

constructor

constructor(address module_, address poolManager_);

setFee

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

beforeInitialize

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

function not implemented, ArrakisPrivateHook will not support this hook.

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

afterInitialize

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

function not implemented, ArrakisPrivateHook will not support this hook.

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

beforeAddLiquidity

The hook called before liquidity is added

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

Parameters

afterAddLiquidity

The hook called after liquidity is added.

function not implemented, ArrakisPrivateHook will not support this hook.

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

beforeRemoveLiquidity

The hook called before liquidity is removed.

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

Parameters

afterRemoveLiquidity

The hook called after liquidity is removed.

function not implemented, ArrakisPrivateHook will not support this hook.

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

beforeSwap

The hook called before a swap.

function not implemented, ArrakisPrivateHook will not support this hook.

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

afterSwap

The hook called after a swap.

function not implemented, ArrakisPrivateHook will not support this hook.

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

beforeDonate

The hook called before donate.

function not implemented, ArrakisPrivateHook will not support this hook.

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

afterDonate

The hook called after donate.

function not implemented, ArrakisPrivateHook will not support this hook.

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

Contents

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

AggregatorV3Interface

Git Source

Functions

decimals

function decimals() external view returns (uint8);

description

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

version

function version() external view returns (uint256);

getRoundData

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

latestRoundData

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

IArrakisLPModule

Git Source

Author: Arrakis Finance

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

Functions

pause

function used to pause the module.

only callable by guardian

function pause() external;

unpause

function used to unpause the module.

only callable by guardian

function unpause() external;

initializePosition

function used to initialize the module when a module switch happen

function initializePosition(bytes calldata data_) external;

Parameters

withdraw

function used by metaVault to withdraw tokens from the strategy.

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

Parameters

Returns

withdrawManagerBalance

function used by metaVault or manager to get manager fees.

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

Returns

setManagerFeePIPS

function used to set manager fees.

function setManagerFeePIPS(uint256 newFeePIPS_) external;

Parameters

metaVault

function used to get metaVault as IArrakisMetaVault.

function metaVault() external view returns (IArrakisMetaVault);

Returns

guardian

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

function guardian() external view returns (address);

Returns

managerBalance0

function used to get manager token0 balance.

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

function managerBalance0() external view returns (uint256);

Returns

managerBalance1

function used to get manager token1 balance.

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

function managerBalance1() external view returns (uint256);

Returns

managerFeePIPS

function used to get manager fees.

function managerFeePIPS() external view returns (uint256);

Returns

token0

function used to get token0 as IERC20Metadata.

function token0() external view returns (IERC20Metadata);

Returns

token1

function used to get token1 as IERC20Metadata.

function token1() external view returns (IERC20Metadata);

Returns

getInits

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

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

Returns

totalUnderlying

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

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

Returns

totalUnderlyingAtPrice

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

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

Parameters

Returns

validateRebalance

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

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

Parameters

Events

LogWithdraw

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

withdraw action can be indexed by receiver.

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

Parameters

LogWithdrawManagerBalance

Event describing a manager fee withdrawal.

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

Parameters

LogSetManagerFeePIPS

Event describing manager set his fees.

event LogSetManagerFeePIPS(uint256 oldFee, uint256 newFee);

Parameters

Errors

AddressZero

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

error AddressZero();

OnlyMetaVault

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

error OnlyMetaVault(address caller, address metaVault);

OnlyManager

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

error OnlyManager(address caller, address manager);

ProportionZero

triggered if proportion of minting or burning is zero.

error ProportionZero();

ProportionGtBASE

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

error ProportionGtBASE();

NewFeesGtPIPS

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

error NewFeesGtPIPS(uint256 newFees);

SameManagerFee

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

error SameManagerFee();

InitsAreZeros

triggered when inits values are zeros.

error InitsAreZeros();

OnlyGuardian

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

error OnlyGuardian();

IArrakisLPModuleID

Git Source

Functions

id

function id() external view returns (bytes32);

IArrakisLPModulePrivate

Git Source

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

this deposit feature will be used by private actor.

Functions

fund

deposit function for private vault.

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

Parameters

Events

LogFund

event emitted when owner of private fund the private vault.

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

Parameters

Errors

DepositZero

error DepositZero();

IArrakisLPModulePublic

Git Source

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

this deposit feature will be used by public actor.

Functions

deposit

deposit function for public vault.

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

Parameters

Returns

Events

LogDeposit

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

deposit action can be indexed by depositor.

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

Parameters

IArrakisMetaVault

Git Source

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

Functions

initialize

function used to initialize default module.

function initialize(address module_) external;

Parameters

setModule

function used to set module

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

Parameters

whitelistModules

function used to whitelist modules that can used by manager.

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

Parameters

blacklistModules

function used to blacklist modules that can used by manager.

function blacklistModules(address[] calldata modules_) external;

Parameters

whitelistedModules

function used to get the list of modules whitelisted.

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

Returns

totalUnderlying

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

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

Returns

totalUnderlyingAtPrice

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

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

Parameters

Returns

getInits

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

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

Returns

token0

function used to get the address of token0.

function token0() external view returns (address);

token1

function used to get the address of token1.

function token1() external view returns (address);

manager

function used to get manager address.

function manager() external view returns (address);

module

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

function module() external view returns (IArrakisLPModule);

moduleRegistry

function used to get module registry.

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

Returns

Events

LogWithdrawManagerBalance

Event describing a manager fee withdrawal.

event LogWithdrawManagerBalance(uint256 amount0, uint256 amount1);

Parameters

LogSetManager

Event describing owner setting the manager.

event LogSetManager(address manager);

Parameters

LogSetModule

Event describing manager setting the module.

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

Parameters

LogSetFirstModule

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

event LogSetFirstModule(address module);

Parameters

LogWhiteListedModules

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

event LogWhiteListedModules(address[] modules);

Parameters

LogWhitelistedModule

Event describing whitelisted of the first module during vault creation.

event LogWhitelistedModule(address module);

Parameters

LogBlackListedModules

Event describing blacklisting action of modules by owner.

event LogBlackListedModules(address[] modules);

Parameters

Errors

AddressZero

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

error AddressZero(string property);

OnlyManager

triggered when the caller is different than the manager.

error OnlyManager(address caller, address manager);

CallFailed

triggered when a low level call failed during execution.

error CallFailed();

SameModule

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

error SameModule();

SameManager

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

error SameManager();

ModuleNotEmpty

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

error ModuleNotEmpty(uint256 amount0, uint256 amount1);

AlreadyWhitelisted

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

error AlreadyWhitelisted(address module);

NotWhitelistedModule

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

error NotWhitelistedModule(address module);

ActiveModule

triggered when owner try to blacklist the active module.

error ActiveModule();

Token0GtToken1

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

error Token0GtToken1();

Token0EqToken1

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

error Token0EqToken1();

NotWhitelistedBeacon

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

error NotWhitelistedBeacon();

NotSameGuardian

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

error NotSameGuardian();

NotImplemented

triggered when a function logic is not implemented.

error NotImplemented();

ArrayNotSameLength

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

error ArrayNotSameLength();

OnlyOwner

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

error OnlyOwner();

WithdrawNotAllowed

triggered when setModule action try to remove funds.

error WithdrawNotAllowed();

PositionNotInitialized

triggered when setModule function end without initiliazePosition call.

error PositionNotInitialized();

NotPositionInitializationCall

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

error NotPositionInitializationCall();

IArrakisMetaVaultFactory

Git Source

Functions

pause

function used to pause the factory.

only callable by owner.

function pause() external;

unpause

function used to unpause the factory.

only callable by owner.

function unpause() external;

setManager

function used to set a new manager.

only callable by owner.

function setManager(address newManager_) external;

Parameters

deployPublicVault

function used to deploy ERC20 token wrapped Arrakis Meta Vault.

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

Parameters

Returns

deployPrivateVault

function used to deploy owned Arrakis Meta Vault.

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

Parameters

Returns

whitelistDeployer

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

function whitelistDeployer(address[] calldata deployers_) external;

Parameters

blacklistDeployer

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

function blacklistDeployer(address[] calldata deployers_) external;

Parameters

getTokenName

get Arrakis Modular standard token name for two corresponding tokens.

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

Parameters

Returns

publicVaults

get a list of public vaults created by this factory

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

Parameters

Returns

numOfPublicVaults

numOfPublicVaults counts the total number of token vaults in existence

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

Returns

isPublicVault

isPublicVault check if the inputed vault is a public vault.

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

Parameters

Returns

privateVaults

get a list of private vaults created by this factory

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

Parameters

Returns

numOfPrivateVaults

numOfPrivateVaults counts the total number of private vaults in existence

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

Returns

isPrivateVault

isPrivateVault check if the inputed vault is a private vault.

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

Parameters

Returns

manager

function used to get the manager of newly deployed vault.

function manager() external view returns (address);

Returns

deployers

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

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

moduleRegistryPublic

function used to get public module registry.

function moduleRegistryPublic() external view returns (address);

moduleRegistryPrivate

function used to get private module registry.

function moduleRegistryPrivate() external view returns (address);

Events

LogPublicVaultCreation

event emitted when public vault is created by a deployer.

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

Parameters

LogPrivateVaultCreation

event emitted when private vault is created.

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

Parameters

LogWhitelistDeployers

event emitted when whitelisting an array of public vault deployers.

event LogWhitelistDeployers(address[] deployers);

Parameters

LogBlacklistDeployers

event emitted when blacklisting an array of public vault deployers.

event LogBlacklistDeployers(address[] deployers);

Parameters

LogSetManager

event emitted when owner set a new manager.

event LogSetManager(address oldManager, address newManager);

Parameters