Malda Lending Protocol – Technical Overview

Malda is a modern lending protocol enhanced with cross-chain capabilities using zk-coprocessor proofs (Risc0) and extension gateways for remote execution. It retains core economic primitives of a secure lending protocol, while introducing mTokenHost / mTokenGateway pairs for cross-chain liquidity and borrowing.

🔧 Core Components

Operator

Purpose

The Operator contract is the central authority that governs markets, collateral factors, account liquidity, liquidation thresholds, and policy enforcement (who can mint, redeem, borrow, repay etc).

The Operator serves as the protocol’s risk management layer, enforcing collateral requirements and determining liquidation conditions. It evaluates each user’s position to decide the necessary collateral and the extent of possible liquidation. Every time a user interacts with an mToken, the Operator assesses and approves or rejects the transaction.

It interacts with mTokens, IPriceOracle, and IInterestRateModel to ensure the stability and security of the platform.

Responsibilities

• Market listing and pausing
• Setting risk parameters (collateral factor, liquidation incentive, caps)
• Computing account liquidity and shortfall
• Authorizing mints, redeems, borrows, repayments, liquidations
• Disable/Enable whitelist
• Define outflow volume time and value limits (outflow volume defines the maximum amount of tokens that can go through sequencer between a specified time window)
• Compute each user's account liquidity or shortfall (determine how much a user can borrow based on their supplied assets and collateral factors)

The following Operator methods act as notification/trigger for various mToken lending operations

function beforeMTokenTransfer(address mToken, address src, address dst, uint256 transferTokens) external;    

function beforeMTokenMint(address mToken, address minter) external;    

function afterMTokenMint(address mToken) external view;    

function beforeMTokenRedeem(address mToken, address redeemer, uint256 redeemTokens) external;    

function beforeMTokenBorrow(address mToken, address borrower, uint256 borrowAmount) external;    

function beforeMTokenRepay(address mToken, address borrower) external;    

function beforeMTokenLiquidate(
    address mTokenBorrowed,        
    address mTokenCollateral,        
    address borrower,        
    uint256 repayAmount
) external view;    

function beforeMTokenSeize(address mTokenCollateral, address mTokenBorrowed, address liquidator, address borrower) external;

As mentioned, Operator acts as a guardian for the mToken contract. Below is a list of methods created for this purpose:

  function rolesOperator() external view returns (IRoles);    
  
  function oracleOperator() external view returns (address);    
  
  function closeFactorMantissa() external view returns (uint256);    
  
  function liquidationIncentiveMantissa() external view returns (uint256);    
  
  function getAssetsIn(address _user) external view returns (address[] memory mTokens);    
  
  function getAllMarkets() external view returns (address[] memory mTokens);    
  
  function borrowCaps(address _mToken) external view returns (uint256);    
  
  function supplyCaps(address _mToken) external view returns (uint256);    
  
  function rewardDistributor() external view returns (address);

mErc20Host

This contract represents a lending market on the host chain (Linea). The mErc20Host contract extends mErc20Upgradeable and provides cross-chain money market functionalities using zk-proof verification. It interacts with mTokenProofDecoderLib for proof decoding and adheres to ImErc20Host interface.

Purpose

• Accept deposits
• Issue mTokens (Malda interest-bearing tokens)
• Track underlying balance and user shares
• Uses IRoles contract for role-based permissioning.
• Uses ZkVerifier to verify proof data before allowing withdrawals. This is using Risc0 libraries under the hood (Steel)
• Admin and specific roles (example: GUARDIAN_PAUSE, REBALANCER, PROOF_FORWARDER) can perform privileged actions.
• Support mint/redeem/borrow/repay on the local chain

   function mint(uint256 mintAmount) external; 
   function redeem(uint256 redeemTokens) external; 
   function redeemUnderlying(uint256 redeemAmount) external; 
   function borrow(uint256 borrowAmount) external; 
   function repay(uint256 repayAmount) external; 
   function repayBehalf(address borrower, uint256 repayAmount) external; 
   function liquidate(address borrower, uint256 repayAmount, address mTokenCollateral) external; 
   function addReserves(uint256 addAmount) external;
  

• Validate and execute zk-coprocessor proofs for cross-chain operations

  • Accumulated{} struct tracks cumulative deposits and withdrawals per user and chain. Both the mTokenGateway (described in next section) and mErc20Host markets accumulate amountsIn and amountsOut per user. Whenever there’s a supply operation performed, the amountsIn is increased. That means that when the proof is submitted on the destination chain the proof was generated for it checks the difference between received amountIn and that chain’s registered amountIn. This difference represents the maximum amount the user can use for operations tied to an amountIn flow, like mint, repay, liquidate.

  • Cross-chain ZK operations: Accepts proof inputs from the zk-coprocessor that attest a valid state transition from another chain. Once verified, calls local internal methods to:

    function  liquidateExternal
    function  mintExternal
    function  repayExternal    
    

  • Remote borrowing/withdrawal: Via performExtensionCall; this contract emits an event or performs outbound call intended to be picked up by the sequencer to the destination chain.

mToken amount is computed according to the following formula (mTokenBalance* exchangeRate / 10^18 / 10^(underlying token decimals)) * underlying_price. The underlying_price is retrieved fromMixedPriceOracleV3 oracle implementation

mTokenGateway (Extension Market)

This contract mirrors the mTokenHost, but lives on an extension chain. The mTokenGateway contract serves as a gateway for handling token operations similar to the mErc20Host contract. It’s the extensions (not Linea) chains’ equivalent of a market.

It has support for role-based access control, proof verification, and cross-chain interactions. It manages deposits, withdrawals, and caller permissions while ensuring security through zero-knowledge (ZK) proof validation.

You can think of the mTokenGateway as a small version of a market or a market’s gateway as the only important operations this is handling are: supplying tokens or withdrawing tokens.

Unique Behavior

• Doesn’t store full balance logic — that lives in the Host
• All actual capital sits on the host chain
• Exposes simplified interface for supply type actions which are only valid once settled on the host chain
• Uses IRoles contract for role-based permissioning.
• Uses ZkVerifier to verify proof data before allowing withdrawals. This is using risc0 libraries under the hood (Steel)

function supplyOnHost(uint256 amount, bytes4 lineaSelector) external override notPaused(OperationType.AmountIn)
function outHere(bytes calldata journalData, bytes calldata seal, uint256 amount, address receiver)

When funds are supplied accAmountIn is increased. This is part of the proof generated with getProofData

    /**     
    * @inheritdoc ImTokenGateway     
    */    
    function getProofData(address user) external view returns (bytes memory) {
        return mTokenProofDecoderLib.encodeJournal(
            user, address(this), accAmountIn[user], accAmountOut[user], uint32(block.chainid), LINEA_CHAIN_ID
        );    
    }

The mTokenProofDecoderLib is performing an abi.encodePacked operation on the data provided and uses BytesLib for the decode operation.

return abi.encodePacked(sender, market, accAmountIn, accAmountOut, chainId, dstChainId);

🔁 Cross-Chain Flow

Malda Protocol solves the fragmentation problem in DeFi by creating a unified lending experience across multiple EVM networks. The protocol enables users to:

• Access lending markets across different L2s as if they were a single network

• Unified liquidity and interest rates across all chains

• Execute lending operations across chains without bridging or wrapping assets

• Maintain full control of their funds in a self-custodial manner

Extension to Host (Deposit / Proof Flow)

1. User deposits tokens into mTokenGateway (extension).

2. Extension records this and updates its internal state hash.

3. ZK coprocessor (Risc0) proves this transition off-chain.

4. Proof is sent to mErc20Host, which verifies it.

5. Host mints (or any other supply type action allowed by the host contract) tokens for the user and updates supply.

Host to Extension (Withdraw / Borrow Flow)

1. User initiates borrow or withdraw on mErc20Host using performExtensionCall method.

2. Contract emits a cross-chain event / message.

3. The sequencer picks up the message.

4. mTokenGateway finalizes the borrow or redeem action.

ZK Coprocessor Proof Validation

The ZkVerifier contract is an abstract contract designed to facilitate the verification of zero-knowledge proofs using the Risc0 framework. It manages a verifier contract instance, an image ID, and provides methods for verifying inputs based on cryptographic proofs. Uses Steel to verify a proof

The following code illustrates how a verification performed:

  function __verify(bytes calldata journalEntry, bytes calldata seal) private view {
      verifier.verify(seal, imageId, sha256(journalEntry));
  }

Proofs are generated using getProofData() calls available on mTokenGateway and mErc20Host contracts. A proof consists of the following fields:

• the user for which the proof is generated for; user
• the market address the proof is intended to be used for; market
• the accumulated amount in for user on the current chain the proof is generated on; accAmountIn[user]
• the accumulated amount out for user on the current chain the proof is generated on; accAmountOut[user]
• the current chain id in uint32 format; uint32(block.chainid)
• the destination chain id in uint32 format; LINEA_CHAIN_ID

The above fields are part of the mTokenGateway proof. The difference between getProofData() from mTokenGateway and getProofData() from mErc20Host contract is that the host call also needs the destination chain id to generate the proof for. This is skipped on mTokenGateway as the destination is always Linea, defined by LINEA_CHAIN_ID

    uint32 private constant LINEA_CHAIN_ID = 59144;

Security is enforced by requiring proof verification before state updates.

Users have the ability to self-sequence the transactions for themselves, in case of Sequencer failure or if they wish to do it for themselves.

BatchSubmitter

The BatchSubmitter contract facilitates batch processing of multiple operations in a single transaction. It uses zk-proof verification by implementing the Steel library and interacts with mErc20Host and mTokenGateway contracts to execute minting, repaying and withdrawing.

    bytes4 internal constant MINT_SELECTOR = ImErc20Host.mintExternal.selector;
    bytes4 internal constant REPAY_SELECTOR = ImErc20Host.repayExternal.selector;
    bytes4 internal constant OUT_HERE_SELECTOR = ImTokenGateway.outHere.selector;

Pauser

The Pauser contract provides emergency pause functionality for market operations within the lending protocol. It allows the owner and authorized roles to pause individual or all market operations in case of an emergency. The contract maintains a registry of pausable markets and their types, enabling controlled break of operations.

The Pauser acts as a guardian for pausable contracts. It can be integrated with solutions like Hypernative to emergency pause 1 operation of a market, the entire market or even all pausable contracts in 1 tx.

// pause a market entirely    
function emergencyPauseMarket(address _market) external;
      
// pause a specific operation for a market    
function emergencyPauseMarketFor(address _market, OperationType _pauseType) external;        
        
// pause everything configured in the Pauser contract    
function emergencyPauseAll() external;

Interest Model

Borrow APR

The interest rate model for borrowed assets can be calculated using the following formula:

= Base + Multiplier * min(UtilizationRate, Kink) + max(JumpMultiplier * UtilizationRate - Kink, 0)

Supply APR

The interest rate model for supplying assets can be calculated using the following formula: = Distribute (Interest Paid by Borrowers Per Block - Reserve) to all suppliers, and convert it into APY

`= Distribute [(1 + Borrow APY) ^ (1 / BlocksPerYear) - 1] * Total Borrow * (1 - Reserve Factor)` to all suppliers, and convert it into APY

`= {[(1 + Borrow APY) ^ (1 / BlocksPerYear) - 1] * Total Borrow * (1 - Reserve Factor) / Total Supply}`, and convert it into APY

`= {1 + [(1 + Borrow APY) ^ (1/BlocksPerYear) - 1] * Total Borrow * (1 - Reserve Factor) / Total Supply} ^ BlocksPerYear - 1`

Using the same interest model as Mendi: https://docs.mendi.finance/protocol/interest-rate-model

Rebalancer

The Rebalancer contract is responsible for managing liquidity rebalancing across different markets and chains. It ensures that funds can be transferred securely using whitelisted bridge contracts while maintaining a log of all rebalancing messages.

It extracts funds from mTokenGateway or mErc20Host contracts and sends to another layer, to the same market, using an implemented IBridge .

The rebalancing module continuously monitors borrow activity on Malda and other money markets, chains’ inflows and outflows, and additional metrics to forecast future borrow demand per chain to rebalance token balances across chains.

The expected borrow demand for a token on a chain is forecasted based on a linear regression of the borrow demand over the last 7 days. If forecasts are shown to be inaccurate, other formulas will be used to minimize the observed delta.

Additional signals include deviations in general borrow demand on other money markets or outliers of chain inflows/outflows.

  // retrieve amounts (make sure to check min and max for that bridge)  IRebalanceMarket(_market).extractForRebalancing(_amount);  ...  IBridge(_bridge).sendMsg{value: msg.value}(_msg.dstChainId, _msg.token, _msg.message, _msg.bridgeData);

Key aspects:

• Manages whitelisted bridge contracts
• Sends messages for rebalancing across chains
• Ensures only authorized addresses can perform rebalancing operations
• Logs rebalancing messages to maintain a history
• Ensures only authorized roles can modify bridge whitelisting and initiate rebalancing.
• Prevents unauthorized token transfers by checking _underlying matches _msg.token.
• Uses SafeApprove to mitigate token approval risks.

Across bridge (IBridge)

The AccrossBridge contract facilitates cross-chain liquidity transfers using the Across protocol. It extends BaseBridge and implements IBridge . It integrates with the Across Spoke Pool for cross-chain transfers.

Everclear bridge (IBridge)

The EverclearBridge contract enables cross-chain liquidity transfers using the Everclear protocol. It extends BaseBridge and implements IBridge . It integrates with IEverclearSpoke to send cross-chain liquidity. Implements getFee to estimate transfer costs.

Deployer

The Deployer contract is responsible for deploying other smart contracts using CREATE3. It allows an admin to create contracts deterministically, retrieve precomputed addresses, and manage contract deployment permissions.

Key aspects:

• Uses CREATE3 to deploy contracts deterministically
• Allows the admin to precompute contract addresses
• Provides mechanisms for transferring ETH stored in the contract
• Enables admin role management

The Deployer contract will be deployed using CREATE2 on multiple chains. The following is similar to the CREATE3Factory contract, except that it’s protected by admin role.

CREATE3 is implemented by the following library:

// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.28;

import {Bytes32AddressLib} from "./Bytes32AddressLib.sol";

/// @notice Deploy to deterministic addresses without an initcode factor.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/CREATE3.sol)
/// @author Modified from 0xSequence (https://github.com/0xSequence/create3/blob/master/contracts/Create3.sol)
library CREATE3 {
    using Bytes32AddressLib for bytes32;

    //--------------------------------------------------------------------------------//
    // Opcode     | Opcode + Arguments    | Description      | Stack View             //
    //--------------------------------------------------------------------------------//
    // 0x36       |  0x36                 | CALLDATASIZE     | size                   //
    // 0x3d       |  0x3d                 | RETURNDATASIZE   | 0 size                 //
    // 0x3d       |  0x3d                 | RETURNDATASIZE   | 0 0 size               //
    // 0x37       |  0x37                 | CALLDATACOPY     |                        //
    // 0x36       |  0x36                 | CALLDATASIZE     | size                   //
    // 0x3d       |  0x3d                 | RETURNDATASIZE   | 0 size                 //
    // 0x34       |  0x34                 | CALLVALUE        | value 0 size           //
    // 0xf0       |  0xf0                 | CREATE           | newContract            //
    //--------------------------------------------------------------------------------//
    // Opcode     | Opcode + Arguments    | Description      | Stack View             //
    //--------------------------------------------------------------------------------//
    // 0x67       |  0x67XXXXXXXXXXXXXXXX | PUSH8 bytecode   | bytecode               //
    // 0x3d       |  0x3d                 | RETURNDATASIZE   | 0 bytecode             //
    // 0x52       |  0x52                 | MSTORE           |                        //
    // 0x60       |  0x6008               | PUSH1 08         | 8                      //
    // 0x60       |  0x6018               | PUSH1 18         | 24 8                   //
    // 0xf3       |  0xf3                 | RETURN           |                        //
    //--------------------------------------------------------------------------------//
    bytes internal constant PROXY_BYTECODE = hex"67363d3d37363d34f03d5260086018f3";

    bytes32 internal constant PROXY_BYTECODE_HASH = keccak256(PROXY_BYTECODE);

    function deploy(bytes32 salt, bytes memory creationCode, uint256 value) internal returns (address deployed) {
        bytes memory proxyChildBytecode = PROXY_BYTECODE;

        address proxy;
        assembly {
            // Deploy a new contract with our pre-made bytecode via CREATE2.
            // We start 32 bytes into the code to avoid copying the byte length.
            proxy := create2(0, add(proxyChildBytecode, 32), mload(proxyChildBytecode), salt)
        }
        require(proxy != address(0), "DEPLOYMENT_FAILED");

        deployed = getDeployed(salt);
        (bool success,) = proxy.call{value: value}(creationCode);
        require(success && deployed.code.length != 0, "INITIALIZATION_FAILED");
    }

    function getDeployed(bytes32 salt) internal view returns (address) {
        address proxy = keccak256(abi.encodePacked(bytes1(0xFF), address(this), salt, PROXY_BYTECODE_HASH))
            // Prefix:
            // Creator:
            // Salt:
            // Bytecode hash:
            .fromLast20Bytes();

        return keccak256(abi.encodePacked(hex"d694", proxy, hex"01")) // Nonce of the proxy contract (1)
            // 0xd6 = 0xc0 (short RLP prefix) + 0x16 (length of: 0x94 ++ proxy ++ 0x01)
            // 0x94 = 0x80 + 0x14 (0x14 = the length of an address, 20 bytes, in hex)
            .fromLast20Bytes();
    }
}

🚀 Dev Onboarding & Recipes

Malda has multiple new use cases and advantages compared to traditional architecture:

• Ability to use 1 (!) money market as a DeFi bank to manage all investments through the major rollups of the Ethereum ecosystem

• Seamless arbitrage across chains with borrowed funds between DEXs

• Easy and convenient user-experience without needing to disrupt user flow to bridge between chains.

• Quick access to investment opportunity with the ability to borrow or withdraw on supported chains instantaneously.

• Easy migration and access for Ethereum Mainnet liquidity to major rollups

• Scale and Depth - Currently legacy lending models suffer fragmented liquidity and it is dependent on the underlying chain the quality of the service they can provide. Malda removes this limitation and provides the full depth of liquidity to all served markets, increasing capital efficiency and fostering meaningful economic growth in the Ethereum ecosystem.

Besides the more complex scenarios, Malda allows simple ones as:

Deploy a new market

• Deploy mErc20Host and configure (collateral, reserve factors etc)
• Deploy mTokenGateway and configure (collateral, reserve factors etc)
• Register market in Operator
• Configure interest rate model, oracle, and caps
• Assign roles using IRoles

Minting mTokens

To deposit funds and receive interest-bearing mTokens:

• Approve the mToken contract to spend your underlying token:

IERC20(underlying).approve(mErc20Host, amount);

• Mint mTokens by calling

mErc20Host.mint(amount, receiver, minAmountOut);

Borrowing assets

To borrow assets from the protocol (requires sufficient collateral):

• Ensure you've minted mTokens of another market as collateral.

• Call the borrow function:

mErc20Host.borrow(borrowAmount);

Repaying loans

To repay borrowed assets:

• Repay your own loan

IERC20(underlying).approve(mErc20Host, repayAmount);
mErc20Host.repay(repayAmount);

• Repay for another user:

IERC20(underlying).approve(mErc20Host, repayAmount);
mErc20Host.repayBehalf(borrowerAddress, repayAmount);

Redeeming tokens

To withdraw your supplied collateral:

• Redeem by token amount:

mErc20Host.redeem(mTokenAmount);

• Redeem by underlying value:

mErc20Host.redeemUnderlying(underlyingAmount);

Liquidating undercollateralized users

If a user’s borrow exceeds their allowed collateral threshold, you can liquidate their position:

mErc20Host.liquidate(borrower, repayAmount, mTokenCollateral);

Borrow/Withdraw on extension chains

To borrow or redeem on an extension chain, the action initiated on host is:

function  performExtensionCall(uint256  actionType, uint256  amount, uint32  dstChainId) external  payable

where actionType is: 1-borrow, 2-withdraw

Supply from extension

By supplying on an extension chains you are able to liquidate, mint or repay on host (this is automatically performed by the Sequencer)

function  supplyOnHost(uint256  amount, address  receiver, bytes4  lineaSelector)

Deployed contracts

Testnet

Deployed on Linea sepolia (host), Sepolia and OP Sepolia

Mainnet

Deployment Architecture

Chains Involved

• Host Chain: Linea (primary liquidity resides here)

• Extension Chains: L2s or sidechains like Base, Arbitrum, etc.

Deployment Patterns

• Deterministic deployment via CREATE3
• ZK proof verification via Risc0 and Steel ensures valid cross-chain operations

Roles and permissions

Pause & Security Management

    PAUSE_MANAGER – Manages pausing functionality across contracts via the Pauser contract. Required for calling addPausableMarket
    GUARDIAN_PAUSE – Can pause markets by calling setPaused on mTokenGateway and mErc20Host

Market Configuration

    GUARDIAN_BORROW_CAP – Can set borrow limits on mTokenGateway and mErc20Host. Required for setMarketBorrowCaps
    GUARDIAN_SUPPLY_CAP – Can set supply limits on mTokenGateway and mErc20Host. Required for setMarketSupplyCaps
    GUARDIAN_ORACLE – Can configure the oracle by calling .setConfig. Required for `setConfig
    GUARDIAN_BRIDGE – Can whitelist bridges on Rebalancer.sol and configure IBridge contracts

Proofs

    PROOF_BATCH_FORWARDER – Roles used in BatchSubmitter to enable batch submission of proofs, typically assigned to the relayer

Reserve & Rebalancing

    GUARDIAN_RESERVE – Can call reduceReserve on mErc20Host
    REBALANCER_EOA – Authorized to call sendMsg on Rebalancer.sol to trigger rebalancing
    REBALANCER – Must be assigned to the Rebalancer.sol contract for operational functionality 

Cross-Chain Management

    CHAINS_MANAGER – Can update the list of allowed destination chains on mErc20Host. Required for calling updateAllowedChain

Contents

• EmptyOperator
• Operator
• OperatorStorage

EmptyOperator

Git Source

Title: EmptyOperator

Author: Merge Layers Inc.

Empty operator contract

Functions

isOperator

Checks if the caller is an operator

function isOperator() external pure returns (bool);

Returns

Operator

Git Source

Inherits: OperatorStorage, ImTokenOperationTypes, OwnableUpgradeable, HypernativeFirewallProtected

Title: Operator core controller

Author: Merge Layers Inc.

Access-controlled operator logic for mTokens

Functions

onlyAllowedUser

Modifier to restrict access to allowed users only

modifier onlyAllowedUser(address user) ;

Parameters

ifNotBlacklisted

Modifier to check if user is not blacklisted

modifier ifNotBlacklisted(address user) ;

Parameters

constructor

Disables initializers for implementation contract

Note: oz-upgrades-unsafe-allow: constructor

constructor() ;

initFirewall

Initializes the firewall

function initFirewall(address _firewall) external onlyOwner;

Parameters

setBlacklister

Sets the blacklist operator

function setBlacklister(address _blacklister) external onlyOwner;

Parameters

setBorrowSizeMin

Sets min borrow size per market

function setBorrowSizeMin(address[] calldata mTokens, uint256[] calldata amounts) external onlyOwner;

Parameters

setWhitelistedUser

Sets user whitelist status

function setWhitelistedUser(address user, bool state) external onlyOwner;

Parameters

setWhitelistStatus

Sets the whitelist status

function setWhitelistStatus(bool status) external onlyOwner;

Parameters

setRolesOperator

Sets a new Operator for the market

function setRolesOperator(address _roles) external onlyOwner;

Parameters

setPriceOracle

Sets a new price oracle

Admin function to set a new price oracle

function setPriceOracle(address newOracle) external onlyOwner;

Parameters

setCloseFactor

Sets the closeFactor used when liquidating borrows

Admin function to set closeFactor

function setCloseFactor(uint256 newCloseFactorMantissa) external onlyOwner;

Parameters

setCollateralFactor

Sets the collateralFactor for a market

Admin function to set per-market collateralFactor

function setCollateralFactor(address mToken, uint256 newCollateralFactorMantissa) external onlyOwner;

Parameters

setLiquidationIncentive

Sets liquidationIncentive

Admin function to set liquidationIncentive

function setLiquidationIncentive(address market, uint256 newLiquidationIncentiveMantissa) external onlyOwner;

Parameters

supportMarket

Add the market to the markets mapping and set it as listed

Admin function to set isListed and add support for the market

function supportMarket(address mToken) external onlyOwner;

Parameters

setOutflowVolumeTimeWindow

Sets outflow volume time window

function setOutflowVolumeTimeWindow(uint256 newTimeWindow) external onlyOwner;

Parameters

setOutflowTimeLimitInUSD

Sets outflow volume limit

when 0, it means there's no limit

function setOutflowTimeLimitInUSD(uint256 amount) external onlyOwner;

Parameters

resetOutflowVolume

Resets outflow volume

function resetOutflowVolume() external onlyOwner;

checkOutflowVolumeLimit

Verifies outflow volume limit

function checkOutflowVolumeLimit(uint256 amount) external;

Parameters

setMarketBorrowCaps

Set borrow caps for given mToken markets.

Borrowing that brings total borrows to or above borrow cap will revert. A value of 0 corresponds to unlimited borrowing.

function setMarketBorrowCaps(address[] calldata mTokens, uint256[] calldata newBorrowCaps)
    external
    onlyFirewallApproved;

Parameters

setMarketSupplyCaps

Set supply caps for the given mToken markets.

Supplying that brings total supply to or above supply cap will revert. A value of 0 corresponds to unlimited supplying.

function setMarketSupplyCaps(address[] calldata mTokens, uint256[] calldata newSupplyCaps)
    external
    onlyFirewallApproved;

Parameters

setPaused

Set pause for a specific operation

function setPaused(address mToken, ImTokenOperationTypes.OperationType _type, bool state)
    external
    onlyFirewallApproved;

Parameters

initialize

Initialize the contract

function initialize(address _rolesOperator, address _blacklistOperator, address _admin) external initializer;

Parameters

enterMarkets

Add assets to be included in account liquidity calculation

function enterMarkets(address[] calldata _mTokens)
    external
    override
    onlyAllowedUser(msg.sender)
    onlyFirewallApproved;

Parameters

enterMarketsWithSender

Add asset (msg.sender) to be included in account liquidity calculation

function enterMarketsWithSender(address _account) external override onlyAllowedUser(_account);

Parameters

exitMarket

Removes asset from sender's account liquidity calculation

Sender must not have an outstanding borrow balance in the asset, and must not be providing necessary collateral for an outstanding borrow.

function exitMarket(address _mToken) external override onlyFirewallApproved;

Parameters

beforeMTokenTransfer

Checks if the account should be allowed to transfer tokens in the given market

function beforeMTokenTransfer(address mToken, address src, address dst, uint256 transferTokens)
    external
    override
    ifNotBlacklisted(src)
    ifNotBlacklisted(dst)
    onlyFirewallApproved;

Parameters

beforeMTokenBorrow

Checks if the account should be allowed to borrow the underlying asset of the given market

function beforeMTokenBorrow(address mToken, address borrower, uint256 borrowAmount)
    external
    override
    onlyAllowedUser(borrower)
    ifNotBlacklisted(borrower)
    onlyFirewallApproved;

Parameters

isPaused

Returns if operation is paused

function isPaused(address mToken, ImTokenOperationTypes.OperationType _type) external view override returns (bool);

Parameters

Returns

getAssetsIn

Returns the assets an account has entered

function getAssetsIn(address _user) external view override returns (address[] memory mTokens);

Parameters

Returns

checkMembership

Returns whether the given account is entered in the given asset

function checkMembership(address account, address mToken) external view returns (bool);

Parameters

Returns

getAllMarkets

A list of all markets

function getAllMarkets() external view returns (address[] memory mTokens);

Returns

isDeprecated

Returns true if the given mToken market has been deprecated

All borrows in a deprecated mToken market can be immediately liquidated

function isDeprecated(address mToken) external view override returns (bool);

Parameters

Returns

isMarketListed

Returns true/false

function isMarketListed(address mToken) external view override returns (bool);

Parameters

Returns

getHypotheticalAccountLiquidity

Determine what the account liquidity would be if the given amounts were redeemed/borrowed

function getHypotheticalAccountLiquidity(
    address account,
    address mTokenModify,
    uint256 redeemTokens,
    uint256 borrowAmount
) external view returns (uint256, uint256);

Parameters

Returns

beforeMTokenMint

Checks if the account should be allowed to mint tokens in the given market

function beforeMTokenMint(address mToken, address minter, address receiver)
    external
    view
    override
    onlyAllowedUser(minter)
    ifNotBlacklisted(minter)
    ifNotBlacklisted(receiver)
    onlyFirewallApproved
    onlyAllowedUser(minter);

Parameters

afterMTokenMint

Validates mint and reverts on rejection. May emit logs.

function afterMTokenMint(address mToken) external view override;

Parameters

beforeMTokenRedeem

Checks if the account should be allowed to redeem tokens in the given market

function beforeMTokenRedeem(address mToken, address redeemer, uint256 redeemTokens)
    external
    view
    override
    onlyAllowedUser(redeemer)
    ifNotBlacklisted(redeemer)
    onlyFirewallApproved;

Parameters

beforeMTokenRepay

Checks if the account should be allowed to repay a borrow in the given market

function beforeMTokenRepay(address mToken, address borrower)
    external
    view
    onlyAllowedUser(borrower)
    onlyFirewallApproved;

Parameters

beforeMTokenLiquidate

Checks if the liquidation should be allowed to occur

function beforeMTokenLiquidate(
    address mTokenBorrowed,
    address mTokenCollateral,
    address borrower,
    uint256 repayAmount
) external view override onlyFirewallApproved;

Parameters

beforeMTokenSeize

Checks if the seizing of assets should be allowed to occur

function beforeMTokenSeize(address mTokenCollateral, address mTokenBorrowed, address liquidator)
    external
    view
    override
    ifNotBlacklisted(liquidator)
    onlyFirewallApproved;

Parameters

getUSDValueForAllMarkets

Returns USD value for all markets

function getUSDValueForAllMarkets() external view returns (uint256 sum);

Returns

beforeRebalancing

Checks if the account should be allowed to rebalance tokens

function beforeRebalancing(address mToken) external view override onlyFirewallApproved;

Parameters

firewallRegister

Registers an account with the firewall

function firewallRegister(address _account) public override(HypernativeFirewallProtected);

Parameters

_convertMarketAmountToUSDValue

Converts a market amount to USD value

function _convertMarketAmountToUSDValue(uint256 amount, address mToken) internal view returns (uint256 usdValue);

Parameters

Returns

_activateMarket

Activates a market for a borrower

function _activateMarket(address _mToken, address borrower) private;

Parameters

_beforeRedeem

Checks if the redeemer is in the market and has sufficient liquidity

function _beforeRedeem(address mToken, address redeemer, uint256 redeemTokens) private view;

Parameters

_getHypotheticalAccountLiquidity

Gets the hypothetical account liquidity

function _getHypotheticalAccountLiquidity(
    address account,
    address mTokenModify,
    uint256 redeemTokens,
    uint256 borrowAmount
) private view returns (uint256, uint256);

Parameters

Returns

_isDeprecated

Checks if a market is deprecated

function _isDeprecated(address mToken) private view returns (bool);

Parameters

Returns

Events

NewBlacklister

Emitted when blacklist operator is updated

event NewBlacklister(address indexed newBlacklister);

Parameters

Errors

Operator_AddressNotValid

Error thrown when address is not valid

error Operator_AddressNotValid();

OperatorStorage

Git Source

Inherits: IOperator, IOperatorDefender, ExponentialNoError

Title: OperatorStorage

Author: Merge Layers Inc.

Storage contract for Operator

State Variables

CLOSE_FACTOR_MIN_MANTISSA

closeFactorMantissa must be strictly greater than this value

uint256 internal constant CLOSE_FACTOR_MIN_MANTISSA = 0.05e18

CLOSE_FACTOR_MAX_MANTISSA

closeFactorMantissa must not exceed this value

uint256 internal constant CLOSE_FACTOR_MAX_MANTISSA = 0.9e18

COLLATERAL_FACTOR_MAX_MANTISSA

No collateralFactorMantissa may exceed this value

uint256 internal constant COLLATERAL_FACTOR_MAX_MANTISSA = 0.9e18

rolesOperator

Roles

IRoles public rolesOperator

blacklistOperator

Blacklist

IBlacklister public blacklistOperator

oracleOperator

Oracle which gives the price of any given asset

address public oracleOperator

closeFactorMantissa

Multiplier used to calculate the maximum repayAmount when liquidating a borrow

uint256 public closeFactorMantissa

liquidationIncentiveMantissa

Mapping of markets to liquidation incentive mantissa

mapping(address market => uint256 incentive) public liquidationIncentiveMantissa

accountAssets

Per-account mapping of "assets you are in", capped by maxAssets

mapping(address account => address[] assets) public accountAssets

markets

Mapping of mTokens to market data

Used e.g. to determine if a market is supported

mapping(address mToken => IOperatorData.Market market) public markets

allMarkets

A list of all markets

address[] public allMarkets

borrowCaps

Mapping of mTokens to borrow caps

mapping(address mToken => uint256 cap) public borrowCaps

supplyCaps

Mapping of mTokens to supply caps

mapping(address mToken => uint256 cap) public supplyCaps

minBorrowSize

Mapping of mTokens to minimum borrow size

mapping(address mToken => uint256 size) public minBorrowSize

limitPerTimePeriod

Should return outflow limit

uint256 public limitPerTimePeriod

cumulativeOutflowVolume

Should return outflow volume

uint256 public cumulativeOutflowVolume

lastOutflowResetTimestamp

Should return last reset time for outflow check

uint256 public lastOutflowResetTimestamp

outflowResetTimeWindow

Should return the outflow volume time window

uint256 public outflowResetTimeWindow

userWhitelisted

Mapping of users to whitelist status

mapping(address user => bool whitelisted) public userWhitelisted

whitelistEnabled

Whether whitelist is enabled

bool public whitelistEnabled

_paused

Mapping of mTokens to operation types to pause status

mapping(address mToken => mapping(ImTokenOperationTypes.OperationType actionType => bool paused)) internal _paused

__gap

uint256[50] private __gap

Events

UserWhitelisted

Emitted when user whitelist status is changed

event UserWhitelisted(address indexed user, bool state);

Parameters

WhitelistEnabled

Emitted when whitelist is enabled

event WhitelistEnabled();

WhitelistDisabled

Emitted when whitelist is disabled

event WhitelistDisabled();

ActionPaused

Emitted when pause status is changed

event ActionPaused(address indexed mToken, ImTokenOperationTypes.OperationType _type, bool state);

Parameters

NewBorrowCap

Emitted when borrow cap for a mToken is changed

event NewBorrowCap(address indexed mToken, uint256 newBorrowCap);

Parameters

NewSupplyCap

Emitted when supply cap for a mToken is changed

event NewSupplyCap(address indexed mToken, uint256 newBorrowCap);

Parameters

MarketListed

Emitted when an admin supports a market

event MarketListed(address mToken);

Parameters

MarketEntered

Emitted when an account enters a market

event MarketEntered(address indexed mToken, address indexed account);

Parameters

MarketExited

Emitted when an account exits a market

event MarketExited(address indexed mToken, address indexed account);

Parameters

NewCloseFactor

Emitted when close factor is changed by admin

event NewCloseFactor(uint256 oldCloseFactorMantissa, uint256 newCloseFactorMantissa);

Parameters

NewCollateralFactor

Emitted when a collateral factor is changed by admin

event NewCollateralFactor(
    address indexed mToken, uint256 oldCollateralFactorMantissa, uint256 newCollateralFactorMantissa
);

Parameters

NewLiquidationIncentive

Emitted when liquidation incentive is changed by admin

event NewLiquidationIncentive(
    address market, uint256 oldLiquidationIncentiveMantissa, uint256 newLiquidationIncentiveMantissa
);

Parameters

NewPriceOracle

Emitted when price oracle is changed

event NewPriceOracle(address indexed oldPriceOracle, address indexed newPriceOracle);

Parameters

NewRolesOperator

Event emitted when rolesOperator is changed

event NewRolesOperator(address indexed oldRoles, address indexed newRoles);

Parameters

OutflowLimitUpdated

Event emitted when outflow limit is updated

event OutflowLimitUpdated(address indexed sender, uint256 oldLimit, uint256 newLimit);

Parameters

OutflowTimeWindowUpdated

Event emitted when outflow reset time window is updated

event OutflowTimeWindowUpdated(uint256 oldWindow, uint256 newWindow);

Parameters

OutflowVolumeReset

Event emitted when outflow volume has been reset

event OutflowVolumeReset();

MinBorrowSizeSet

Event emitted when min borrow size set for markets

event MinBorrowSizeSet(address[] markets, uint256[] amounts);

Parameters

Errors

Operator_Paused

Error when action is paused

error Operator_Paused();

Operator_Mismatch

Error when data mismatch occurs

error Operator_Mismatch();

Operator_OnlyAdmin

Error when caller is not admin

error Operator_OnlyAdmin();

Operator_EmptyPrice

Error when oracle price is empty

error Operator_EmptyPrice();

Operator_WrongMarket

Error when wrong market is referenced

error Operator_WrongMarket();

Operator_InvalidInput

Error when input is invalid

error Operator_InvalidInput();

Operator_AssetNotFound

Error when asset is not found

error Operator_AssetNotFound();

Operator_RepayingTooMuch

Error when repay amount exceeds allowed

error Operator_RepayingTooMuch();

Operator_OnlyAdminOrRole

Error when caller lacks admin or role permissions

error Operator_OnlyAdminOrRole();

Operator_MarketNotListed

Error when market is not listed

error Operator_MarketNotListed();

Operator_UserBlacklisted

Error when user is blacklisted

error Operator_UserBlacklisted();

Operator_PriceFetchFailed

Error when price fetch fails

error Operator_PriceFetchFailed();

Operator_SenderMustBeToken

Error when sender must be token

error Operator_SenderMustBeToken();

Operator_UserNotWhitelisted

Error when user is not whitelisted

error Operator_UserNotWhitelisted();

Operator_MarketSupplyReached

Error when market supply cap reached

error Operator_MarketSupplyReached();

Operator_RepayAmountNotValid

Error when repay amount invalid

error Operator_RepayAmountNotValid();

Operator_MarketAlreadyListed

Error when market already listed

error Operator_MarketAlreadyListed();

Operator_OutflowVolumeReached

Error when outflow volume reached

error Operator_OutflowVolumeReached();

Operator_InvalidRolesOperator

Error when roles operator invalid

error Operator_InvalidRolesOperator();

Operator_InsufficientLiquidity

Error when insufficient liquidity

error Operator_InsufficientLiquidity();

Operator_MarketBorrowSizeNotMet

Error when borrow size not met

error Operator_MarketBorrowSizeNotMet();

Operator_MarketBorrowCapReached

Error when borrow cap reached

error Operator_MarketBorrowCapReached();

Operator_InvalidCollateralFactor

Error when collateral factor invalid

error Operator_InvalidCollateralFactor();

Operator_InvalidBlacklistOperator

Error when blacklist operator invalid

error Operator_InvalidBlacklistOperator();

Operator_OracleUnderlyingFetchError

Error when oracle underlying fetch fails

error Operator_OracleUnderlyingFetchError();

Operator_Deactivate_MarketBalanceOwed

Error when market has balance owed during deactivation

error Operator_Deactivate_MarketBalanceOwed();

Structs

AccountLiquidityLocalVars

Local vars for avoiding stack-depth limits in calculating account liquidity.

struct AccountLiquidityLocalVars {
    uint256 sumCollateral;
    uint256 sumBorrowPlusEffects;
    /// @notice Number of mTokens the account owns in the market
    uint256 mTokenBalance;
    /// @notice Amount of underlying that the account has borrowed
    uint256 borrowBalance;
    uint256 exchangeRateMantissa;
    uint256 oraclePriceMantissa;
    uint256 collateralFactorMantissa;
    uint256 liquidationIncentiveMantissa;
    uint256 borrowLimitMantissa;
    Exp collateralFactor;
    Exp exchangeRate;
    Exp oraclePrice;
    Exp tokensToDenom;
}

Contents

• Blacklister

Blacklister

Git Source

Inherits: OwnableUpgradeable, IBlacklister

Title: Blacklister

Author: Merge Layers Inc.

Contract for managing blacklisted addresses

State Variables

isBlacklisted

Mapping of addresses to their blacklist status

mapping(address user => bool isBlacklisted) public isBlacklisted

_blacklistedList

List of blacklisted addresses

address[] private _blacklistedList

rolesOperator

The roles operator contract

IRoles public rolesOperator

Functions

onlyOwnerOrGuardian

Modifier to restrict access to owner or has guardian blacklist role

modifier onlyOwnerOrGuardian() ;

constructor

Disables initializers on implementation contract

Note: oz-upgrades-unsafe-allow: constructor

constructor() ;

initialize

Initialize the contract

function initialize(address payable _owner, address _roles) external initializer;

Parameters

blacklist

Blacklists a user immediately (onlyOwner).

function blacklist(address user) external override onlyOwnerOrGuardian;

Parameters

unblacklist

Removes a user from the blacklist (onlyOwner).

function unblacklist(address user) external override onlyOwnerOrGuardian;

Parameters

unblacklist

Removes a user from the blacklist (onlyOwner).

function unblacklist(address user, uint256 index) external override onlyOwnerOrGuardian;

Parameters

getBlacklistedAddresses

Returns the list of currently blacklisted addresses.

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

Returns

_addToBlacklist

Internal function to add an address to blacklist

function _addToBlacklist(address user) internal;

Parameters

_removeFromBlacklist

Internal function to remove an address from blacklist list

function _removeFromBlacklist(address user) internal;

Parameters

_removeFromBlacklist

Internal function to remove an address from blacklist list by index

function _removeFromBlacklist(address user, uint256 index) internal;

Parameters

Contents

• JumpRateModelV4

JumpRateModelV4

Git Source

Inherits: IInterestRateModel, Ownable

Title: JumpRateModelV4

Author: Merge Layers Inc.

Implementation of the IInterestRateModel interface for calculating interest rates

State Variables

blocksPerYear

The approximate number of blocks per year that is assumed by the interest rate model

uint256 public override blocksPerYear

multiplierPerBlock

The multiplier of utilization rate that gives the slope of the interest rate

uint256 public override multiplierPerBlock

baseRatePerBlock

The base interest rate which is the y-intercept when utilization rate is 0

uint256 public override baseRatePerBlock

jumpMultiplierPerBlock

The multiplierPerBlock after hitting a specified utilization point

uint256 public override jumpMultiplierPerBlock

kink

The utilization point at which the jump multiplier is applied

uint256 public override kink

name

A name for user-friendliness, e.g. WBTC

string public override name

Functions

constructor

Construct an interest rate model

constructor(
    uint256 blocksPerYear_,
    uint256 baseRatePerBlock_,
    uint256 multiplierPerBlock_,
    uint256 jumpMultiplierPerBlock_,
    uint256 kink_,
    address owner_,
    string memory name_
) Ownable(owner_);

Parameters

updateJumpRateModelDirect

Update the parameters of the interest rate model (only callable by owner, i.e. Timelock)

function updateJumpRateModelDirect(
    uint256 baseRatePerBlock_,
    uint256 multiplierPerBlock_,
    uint256 jumpMultiplierPerBlock_,
    uint256 kink_
) external onlyOwner;

Parameters

updateJumpRateModel

Update the parameters of the interest rate model (only callable by owner, i.e. Timelock)

function updateJumpRateModel(
    uint256 baseRatePerYear,
    uint256 multiplierPerYear,
    uint256 jumpMultiplierPerYear,
    uint256 kink_
) external onlyOwner;

Parameters

updateBlocksPerYear

Updates the blocksPerYear in order to make interest calculations simpler

function updateBlocksPerYear(uint256 blocksPerYear_) external onlyOwner;

Parameters

getSupplyRate

Returns the current supply rate per block for the market

function getSupplyRate(uint256 cash, uint256 borrows, uint256 reserves, uint256 reserveFactorMantissa)
    external
    view
    override
    returns (uint256);

Parameters

Returns

isInterestRateModel

Should return true

function isInterestRateModel() external pure override returns (bool);

Returns

getBorrowRate

Returns the current borrow rate per block for the market

function getBorrowRate(uint256 cash, uint256 borrows, uint256 reserves) public view override returns (uint256);

Parameters

Returns

utilizationRate

Calculates the utilization rate of the market

function utilizationRate(uint256 cash, uint256 borrows, uint256 reserves) public pure override returns (uint256);

Parameters

Returns

_updateBlocksPerYear

Internal function to update blocks per year

function _updateBlocksPerYear(uint256 blocksPerYear_) private;

Parameters

_updateJumpRateModelWithoutComputation

Internal function to update jump rate model parameters without computation

function _updateJumpRateModelWithoutComputation(
    uint256 basePerBlock_,
    uint256 multiplierPerBlock_,
    uint256 jumpMultiplierPerBlock_,
    uint256 kink_
) private;

Parameters

_updateJumpRateModel

Internal function to update the parameters of the interest rate model

function _updateJumpRateModel(
    uint256 baseRatePerYear,
    uint256 multiplierPerYear,
    uint256 jumpMultiplierPerYear,
    uint256 kink_
) private;

Parameters

Contents

• external
• IBlacklister
• IBridge
• IDefaultAdapter
• IGasFeesHelper
• IInterestRateModel
• IOperatorData
• IOperatorDefender
• IOperator
• IOracleOperator
• IOwnable
• IPauser
• IRebalanceMarket
• IRebalancer
• IRewardDistributorData
• IRewardDistributor
• IRoles
• ImErc20
• ImErc20Host
• ImTokenOperationTypes
• ImTokenDelegator
• ImTokenMinimal
• ImToken
• ImTokenGateway

Contents

• across
• chainlink
• connext
• everclear
• layerzero
• poh

Contents

• IAcrossReceiverV3
• IAcrossSpokePoolV3

IAcrossReceiverV3

Git Source

Functions

handleV3AcrossMessage

handles AcrossV3 SpokePool message

function handleV3AcrossMessage(address tokenSent, uint256 amount, address relayer, bytes memory message) external;

Parameters

IAcrossSpokePoolV3

Git Source

Functions

depositV3

FUNCTIONS *

function depositV3(
    address depositor,
    address recipient,
    address inputToken,
    address outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 destinationChainId,
    address exclusiveRelayer,
    uint32 quoteTimestamp,
    uint32 fillDeadline,
    uint32 exclusivityDeadline,
    bytes calldata message
) external payable;

depositV3Now

function depositV3Now(
    address depositor,
    address recipient,
    address inputToken,
    address outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 destinationChainId,
    address exclusiveRelayer,
    uint32 fillDeadlineOffset,
    uint32 exclusivityDeadline,
    bytes calldata message
) external payable;

speedUpV3Deposit

function speedUpV3Deposit(
    address depositor,
    uint32 depositId,
    uint256 updatedOutputAmount,
    address updatedRecipient,
    bytes calldata updatedMessage,
    bytes calldata depositorSignature
) external;

fillV3Relay

function fillV3Relay(V3RelayData calldata relayData, uint256 repaymentChainId) external;

fillV3RelayWithUpdatedDeposit

function fillV3RelayWithUpdatedDeposit(
    V3RelayData calldata relayData,
    uint256 repaymentChainId,
    uint256 updatedOutputAmount,
    address updatedRecipient,
    bytes calldata updatedMessage,
    bytes calldata depositorSignature
) external;

requestV3SlowFill

function requestV3SlowFill(V3RelayData calldata relayData) external;

executeV3SlowRelayLeaf

function executeV3SlowRelayLeaf(V3SlowFill calldata slowFillLeaf, uint32 rootBundleId, bytes32[] calldata proof)
    external;

Events

V3FundsDeposited

EVENTS *

event V3FundsDeposited(
    address inputToken,
    address outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 indexed destinationChainId,
    uint32 indexed depositId,
    uint32 quoteTimestamp,
    uint32 fillDeadline,
    uint32 exclusivityDeadline,
    address indexed depositor,
    address recipient,
    address exclusiveRelayer,
    bytes message
);

RequestedSpeedUpV3Deposit

event RequestedSpeedUpV3Deposit(
    uint256 updatedOutputAmount,
    uint32 indexed depositId,
    address indexed depositor,
    address updatedRecipient,
    bytes updatedMessage,
    bytes depositorSignature
);

FilledV3Relay

event FilledV3Relay(
    address inputToken,
    address outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 repaymentChainId,
    uint256 indexed originChainId,
    uint32 indexed depositId,
    uint32 fillDeadline,
    uint32 exclusivityDeadline,
    address exclusiveRelayer,
    address indexed relayer,
    address depositor,
    address recipient,
    bytes message,
    V3RelayExecutionEventInfo relayExecutionInfo
);

RequestedV3SlowFill

event RequestedV3SlowFill(
    address inputToken,
    address outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 indexed originChainId,
    uint32 indexed depositId,
    uint32 fillDeadline,
    uint32 exclusivityDeadline,
    address exclusiveRelayer,
    address depositor,
    address recipient,
    bytes message
);

Errors

DisabledRoute

ERRORS *

error DisabledRoute();

InvalidQuoteTimestamp

error InvalidQuoteTimestamp();

InvalidFillDeadline

error InvalidFillDeadline();

InvalidExclusiveRelayer

error InvalidExclusiveRelayer();

MsgValueDoesNotMatchInputAmount

error MsgValueDoesNotMatchInputAmount();

NotExclusiveRelayer

error NotExclusiveRelayer();

NoSlowFillsInExclusivityWindow

error NoSlowFillsInExclusivityWindow();

RelayFilled

error RelayFilled();

InvalidSlowFillRequest

error InvalidSlowFillRequest();

ExpiredFillDeadline

error ExpiredFillDeadline();

InvalidMerkleProof

error InvalidMerkleProof();

InvalidChainId

error InvalidChainId();

InvalidMerkleLeaf

error InvalidMerkleLeaf();

ClaimedMerkleLeaf

error ClaimedMerkleLeaf();

InvalidPayoutAdjustmentPct

error InvalidPayoutAdjustmentPct();

WrongERC7683OrderId

error WrongERC7683OrderId();

LowLevelCallFailed

error LowLevelCallFailed(bytes data);

Structs

V3RelayData

STRUCTS *

struct V3RelayData {
    // The address that made the deposit on the origin chain.
    address depositor;
    // The recipient address on the destination chain.
    address recipient;
    // This is the exclusive relayer who can fill the deposit before the exclusivity deadline.
    address exclusiveRelayer;
    // Token that is deposited on origin chain by depositor.
    address inputToken;
    // Token that is received on destination chain by recipient.
    address outputToken;
    // The amount of input token deposited by depositor.
    uint256 inputAmount;
    // The amount of output token to be received by recipient.
    uint256 outputAmount;
    // Origin chain id.
    uint256 originChainId;
    // The id uniquely identifying this deposit on the origin chain.
    uint32 depositId;
    // The timestamp on the destination chain after which this deposit can no longer be filled.
    uint32 fillDeadline;
    // The timestamp on the destination chain after which any relayer can fill the deposit.
    uint32 exclusivityDeadline;
    // Data that is forwarded to the recipient.
    bytes message;
}

V3SlowFill

struct V3SlowFill {
    V3RelayData relayData;
    uint256 chainId;
    uint256 updatedOutputAmount;
}

V3RelayExecutionParams

struct V3RelayExecutionParams {
    V3RelayData relay;
    bytes32 relayHash;
    uint256 updatedOutputAmount;
    address updatedRecipient;
    bytes updatedMessage;
    uint256 repaymentChainId;
}

V3RelayExecutionEventInfo

struct V3RelayExecutionEventInfo {
    address updatedRecipient;
    bytes updatedMessage;
    uint256 updatedOutputAmount;
    FillType fillType;
}

Enums

FillStatus

ENUMS *

enum FillStatus {
    Unfilled,
    RequestedSlowFill,
    Filled
}

FillType

enum FillType {
    FastFill,
    // Fast fills are normal fills that do not replace a slow fill request.
    ReplacedSlowFill,
    // Replaced slow fills are fast fills that replace a slow fill request. This type is used by the Dataworker
    // to know when to send excess funds from the SpokePool to the HubPool because they can no longer be used
    // for a slow fill execution.
    SlowFill
}

Contents

• IAggregatorV3

IAggregatorV3

Git Source

Functions

decimals

function decimals() external view returns (uint8);

latestRoundData

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

Contents

• IConnext

IConnext

Git Source

Functions

xcall

function xcall(
    uint32 _destination,
    address _to,
    address _asset,
    address _delegate,
    uint256 _amount,
    uint256 _slippage,
    bytes calldata _callData
) external payable returns (bytes32);

xcall

function xcall(
    uint32 _destination,
    address _to,
    address _asset,
    address _delegate,
    uint256 _amount,
    uint256 _slippage,
    bytes calldata _callData,
    uint256 _relayerFee
) external returns (bytes32);

xcallIntoLocal

function xcallIntoLocal(
    uint32 _destination,
    address _to,
    address _asset,
    address _delegate,
    uint256 _amount,
    uint256 _slippage,
    bytes calldata _callData
) external payable returns (bytes32);

domain

function domain() external view returns (uint256);

Contents

• IEverclearSpoke
• IFeeAdapter

IEverclearSpoke

Git Source

Functions

newIntent

Creates a new intent

function newIntent(
    uint32[] memory _destinations,
    address _receiver,
    address _inputAsset,
    address _outputAsset,
    uint256 _amount,
    uint24 _maxFee,
    uint48 _ttl,
    bytes calldata _data
) external returns (bytes32 _intentId, Intent memory _intent);

Parameters

Returns

Structs

Intent

struct Intent {
    uint256 val;
}

IFeeAdapter

Git Source

Functions

newIntent

function newIntent(
    uint32[] memory _destinations,
    bytes32 _receiver,
    address _inputAsset,
    bytes32 _outputAsset,
    uint256 _amount,
    uint24 _maxFee,
    uint48 _ttl,
    bytes calldata _data,
    FeeParams calldata _feeParams
) external payable returns (bytes32 _intentId, Intent memory _intent);

Structs

Intent

struct Intent {
    bytes32 initiator;
    bytes32 receiver;
    bytes32 inputAsset;
    bytes32 outputAsset;
    uint24 maxFee;
    uint32 origin;
    uint64 nonce;
    uint48 timestamp;
    uint48 ttl;
    uint256 amount;
    uint32[] destinations;
    bytes data;
}

FeeParams

struct FeeParams {
    uint256 fee;
    uint256 deadline;
    bytes sig;
}

Contents

• v2
• ILayerZeroEndpoint
• ILayerZeroReceiver
• ILayerZeroUserApplicationConfig

Contents

• MessagingParams
• MessagingReceipt
• MessagingFee
• Origin
• ILayerZeroEndpointV2
• SendParam
• OFTLimit
• OFTReceipt
• OFTFeeDetail
• ILayerZeroOFT
• ILayerZeroReceiverV2
• MessageLibType
• IMessageLib
• SetConfigParam
• IMessageLibManager
• IMessagingChannel
• IMessagingComposer
• IMessagingContext

MessagingParams

Git Source

struct MessagingParams {
uint32 dstEid;
bytes32 receiver;
bytes message;
bytes options;
bool payInLzToken;
}

MessagingReceipt

Git Source

struct MessagingReceipt {
bytes32 guid;
uint64 nonce;
MessagingFee fee;
}

MessagingFee

Git Source

struct MessagingFee {
uint256 nativeFee;
uint256 lzTokenFee;
}

Origin

Git Source

struct Origin {
uint32 srcEid;
bytes32 sender;
uint64 nonce;
}

ILayerZeroEndpointV2

Git Source

Inherits: IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext

Functions

quote

function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);

send

function send(MessagingParams calldata _params, address _refundAddress)
    external
    payable
    returns (MessagingReceipt memory);

verify

function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;

verifiable

function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);

initializable

function initializable(Origin calldata _origin, address _receiver) external view returns (bool);

lzReceive

function lzReceive(
    Origin calldata _origin,
    address _receiver,
    bytes32 _guid,
    bytes calldata _message,
    bytes calldata _extraData
) external payable;

clear

function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;

setLzToken

function setLzToken(address _lzToken) external;

lzToken

function lzToken() external view returns (address);

nativeToken

function nativeToken() external view returns (address);

setDelegate

function setDelegate(address _delegate) external;

Events

PacketSent

event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);

PacketVerified

event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);

PacketDelivered

event PacketDelivered(Origin origin, address receiver);

LzReceiveAlert

event LzReceiveAlert(
    address indexed receiver,
    address indexed executor,
    Origin origin,
    bytes32 guid,
    uint256 gas,
    uint256 value,
    bytes message,
    bytes extraData,
    bytes reason
);

LzTokenSet

event LzTokenSet(address token);

DelegateSet

event DelegateSet(address sender, address delegate);

SendParam

Git Source

Struct representing token parameters for the OFT send() operation.

struct SendParam {
uint32 dstEid; // Destination endpoint ID.
bytes32 to; // Recipient address.
uint256 amountLD; // Amount to send in local decimals.
uint256 minAmountLD; // Minimum amount to send in local decimals.
bytes extraOptions; // Additional options supplied by the caller to be used in the LayerZero message.
bytes composeMsg; // The composed message for the send() operation.
bytes oftCmd; // The OFT command to be executed, unused in default OFT implementations.
}

OFTLimit

Git Source

Struct representing OFT limit information.

These amounts can change dynamically and are up the the specific oft implementation.

struct OFTLimit {
uint256 minAmountLD; // Minimum amount in local decimals that can be sent to the recipient.
uint256 maxAmountLD; // Maximum amount in local decimals that can be sent to the recipient.
}

OFTReceipt

Git Source

Struct representing OFT receipt information.

struct OFTReceipt {
uint256 amountSentLD; // Amount of tokens ACTUALLY debited from the sender in local decimals.
// @dev In non-default implementations, the amountReceivedLD COULD differ from this value.
uint256 amountReceivedLD; // Amount of tokens to be received on the remote side.
}

OFTFeeDetail

Git Source

Struct representing OFT fee details.

Future proof mechanism to provide a standardized way to communicate fees to things like a UI.

struct OFTFeeDetail {
int256 feeAmountLD; // Amount of the fee in local decimals.
string description; // Description of the fee.
}

ILayerZeroOFT

Git Source

Title: IOFT

Interface for the OftChain (OFT) token.

Does not inherit ERC20 to accommodate usage by OFTAdapter as well.

This specific interface ID is '0x02e49c2c'.

Functions

oftVersion

Retrieves interfaceID and the version of the OFT.

interfaceId: This specific interface ID is '0x02e49c2c'.

version: Indicates a cross-chain compatible msg encoding with other OFTs.

If a new feature is added to the OFT cross-chain msg encoding, the version will be incremented. ie. localOFT version(x,1) CAN send messages to remoteOFT version(x,1)

function oftVersion() external view returns (bytes4 interfaceId, uint64 version);

Returns

token

Retrieves the address of the token associated with the OFT.

function token() external view returns (address);

Returns

approvalRequired

Indicates whether the OFT contract requires approval of the 'token()' to send.

Allows things like wallet implementers to determine integration requirements, without understanding the underlying token implementation.

function approvalRequired() external view returns (bool);

Returns

sharedDecimals

Retrieves the shared decimals of the OFT.

function sharedDecimals() external view returns (uint8);

Returns

quoteOFT

Provides a quote for OFT-related operations.

function quoteOFT(SendParam calldata _sendParam)
    external
    view
    returns (OFTLimit memory, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory);

Parameters

Returns

quoteSend

Provides a quote for the send() operation.

MessagingFee: LayerZero msg fee

• nativeFee: The native fee.
• lzTokenFee: The lzToken fee.

function quoteSend(SendParam calldata _sendParam, bool _payInLzToken) external view returns (MessagingFee memory);

Parameters

Returns

send

Executes the send() operation.

MessagingReceipt: LayerZero msg receipt

• guid: The unique identifier for the sent message.
• nonce: The nonce of the sent message.
• fee: The LayerZero fee incurred for the message.

function send(SendParam calldata _sendParam, MessagingFee calldata _fee, address _refundAddress)
    external
    payable
    returns (MessagingReceipt memory, OFTReceipt memory);

Parameters

Returns

Events

OFTSent

event OFTSent( // GUID of the OFT message.
    // Destination Endpoint ID.
    // Address of the sender on the src chain.
    // Amount of tokens sent in local decimals.
    // Amount of tokens received in local decimals.
    bytes32 indexed guid,
    uint32 dstEid,
    address indexed fromAddress,
    uint256 amountSentLD,
    uint256 amountReceivedLD
);

OFTReceived

event OFTReceived( // GUID of the OFT message.
    // Source Endpoint ID.
    // Address of the recipient on the dst chain.
    // Amount of tokens received in local decimals.
    bytes32 indexed guid,
    uint32 srcEid,
    address indexed toAddress,
    uint256 amountReceivedLD
);

Errors

InvalidLocalDecimals

error InvalidLocalDecimals();

SlippageExceeded

error SlippageExceeded(uint256 amountLD, uint256 minAmountLD);

ILayerZeroReceiverV2

Git Source

Functions

allowInitializePath

function allowInitializePath(Origin calldata _origin) external view returns (bool);

nextNonce

function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);

lzReceive

function lzReceive(
    Origin calldata _origin,
    bytes32 _guid,
    bytes calldata _message,
    address _executor,
    bytes calldata _extraData
) external payable;

MessageLibType

Git Source

enum MessageLibType {
Send,
Receive,
SendAndReceive
}

IMessageLib

Git Source

Inherits: IERC165

Functions

setConfig

function setConfig(address _oapp, SetConfigParam[] calldata _config) external;

getConfig

function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view returns (bytes memory config);

isSupportedEid

function isSupportedEid(uint32 _eid) external view returns (bool);

version

function version() external view returns (uint64 major, uint8 minor, uint8 endpointVersion);

messageLibType

function messageLibType() external view returns (MessageLibType);

SetConfigParam

Git Source

struct SetConfigParam {
uint32 eid;
uint32 configType;
bytes config;
}

IMessageLibManager

Git Source

Functions

registerLibrary

function registerLibrary(address _lib) external;

isRegisteredLibrary

function isRegisteredLibrary(address _lib) external view returns (bool);

getRegisteredLibraries

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

setDefaultSendLibrary

function setDefaultSendLibrary(uint32 _eid, address _newLib) external;

defaultSendLibrary

function defaultSendLibrary(uint32 _eid) external view returns (address);

setDefaultReceiveLibrary

function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _gracePeriod) external;

defaultReceiveLibrary

function defaultReceiveLibrary(uint32 _eid) external view returns (address);

setDefaultReceiveLibraryTimeout

function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;

defaultReceiveLibraryTimeout

function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);

isSupportedEid

function isSupportedEid(uint32 _eid) external view returns (bool);

isValidReceiveLibrary

function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);

setSendLibrary

------------------- OApp interfaces -------------------

function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;

getSendLibrary

function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);

isDefaultSendLibrary

function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);

setReceiveLibrary

function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;

getReceiveLibrary

function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);

setReceiveLibraryTimeout

function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _expiry) external;

receiveLibraryTimeout

function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);

setConfig

function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;

getConfig

function getConfig(address _oapp, address _lib, uint32 _eid, uint32 _configType)
    external
    view
    returns (bytes memory config);

Events

LibraryRegistered

event LibraryRegistered(address newLib);

DefaultSendLibrarySet

event DefaultSendLibrarySet(uint32 eid, address newLib);

DefaultReceiveLibrarySet

event DefaultReceiveLibrarySet(uint32 eid, address newLib);

DefaultReceiveLibraryTimeoutSet

event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);

SendLibrarySet

event SendLibrarySet(address sender, uint32 eid, address newLib);

ReceiveLibrarySet

event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);

ReceiveLibraryTimeoutSet

event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);

Structs

Timeout

struct Timeout {
    address lib;
    uint256 expiry;
}

IMessagingChannel

Git Source

Functions

eid

function eid() external view returns (uint32);

skip

function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;

nilify

function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

burn

function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

nextGuid

function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);

inboundNonce

function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

outboundNonce

function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);

inboundPayloadHash

function inboundPayloadHash(address _receiver, uint32 _srcEid, bytes32 _sender, uint64 _nonce)
    external
    view
    returns (bytes32);

lazyInboundNonce

function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

Events

InboundNonceSkipped

event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);

PacketNilified

event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

PacketBurnt

event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

IMessagingComposer

Git Source

Functions

composeQueue

function composeQueue(address _from, address _to, bytes32 _guid, uint16 _index)
    external
    view
    returns (bytes32 messageHash);

sendCompose

function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;

lzCompose

function lzCompose(
    address _from,
    address _to,
    bytes32 _guid,
    uint16 _index,
    bytes calldata _message,
    bytes calldata _extraData
) external payable;

Events

ComposeSent

event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);

ComposeDelivered

event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);

LzComposeAlert

event LzComposeAlert(
    address indexed from,
    address indexed to,
    address indexed executor,
    bytes32 guid,
    uint16 index,
    uint256 gas,
    uint256 value,
    bytes message,
    bytes extraData,
    bytes reason
);

IMessagingContext

Git Source

Functions

isSendingMessage

function isSendingMessage() external view returns (bool);

getSendContext

function getSendContext() external view returns (uint32 dstEid, address sender);

ILayerZeroEndpoint

Git Source

Inherits: ILayerZeroUserApplicationConfig

is imported from (https://github.com/LayerZero-Labs/LayerZero/blob/main/contracts/interfaces/ILayerZeroEndpoint.sol)

Functions

send

function send(
    uint16 dstChainId_,
    bytes calldata destination_,
    bytes calldata payload_,
    address payable refundAddress_,
    address zroPaymentAddress_,
    bytes calldata adapterParams_
) external payable;

receivePayload

function receivePayload(
    uint16 srcChainId_,
    bytes calldata srcAddress_,
    address dstAddress_,
    uint64 nonce_,
    uint256 gasLimit_,
    bytes calldata payload_
) external;

getInboundNonce

function getInboundNonce(uint16 srcChainId_, bytes calldata srcAddress_) external view returns (uint64);

getOutboundNonce

function getOutboundNonce(uint16 dstChainId_, address srcAddress_) external view returns (uint64);

estimateFees

function estimateFees(
    uint16 dstChainId_,
    address userApplication_,
    bytes calldata payload_,
    bool _payInZRO,
    bytes calldata _adapterParam
) external view returns (uint256 nativeFee, uint256 zroFee);

getChainId

function getChainId() external view returns (uint16);

retryPayload

function retryPayload(uint16 srcChainId_, bytes calldata srcAddress_, bytes calldata payload_) external;

hasStoredPayload

function hasStoredPayload(uint16 srcChainId_, bytes calldata srcAddress_) external view returns (bool);

getSendLibraryAddress

function getSendLibraryAddress(address userApplication_) external view returns (address);

getReceiveLibraryAddress

function getReceiveLibraryAddress(address userApplication_) external view returns (address);

isSendingPayload

function isSendingPayload() external view returns (bool);

isReceivingPayload

function isReceivingPayload() external view returns (bool);

getConfig

function getConfig(uint16 version_, uint16 chainId_, address userApplication_, uint256 configType_)
    external
    view
    returns (bytes memory);

getSendVersion

function getSendVersion(address userApplication_) external view returns (uint16);

getReceiveVersion

function getReceiveVersion(address userApplication_) external view returns (uint16);

ILayerZeroReceiver

Git Source

is imported from (https://github.com/LayerZero-Labs/LayerZero/blob/main/contracts/interfaces/ILayerZeroReceiver.sol)

Functions

lzReceive

function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;

ILayerZeroUserApplicationConfig

Git Source

is imported from (https://github.com/LayerZero-Labs/LayerZero/blob/main/contracts/interfaces/ILayerZeroUserApplicationConfig.sol)

Functions

setConfig

function setConfig(uint16 _version, uint16 _chainId, uint256 _configType, bytes calldata _config) external;

setSendVersion

function setSendVersion(uint16 _version) external;

setReceiveVersion

function setReceiveVersion(uint16 _version) external;

forceResumeReceive

function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;

Contents

• IPohVerifier

IPohVerifier

Git Source

Functions

verify

Check if the provided signature has been signed by signer

human is supposed to be a POH address, this is what is being signed by the POH API

function verify(bytes memory signature, address human) external view returns (bool);

Parameters

Returns

getSigner

Returns the signer's address

function getSigner() external view returns (address);

IBlacklister

Git Source

Title: IBlacklister

Author: Merge Layers Inc.

Interface for blacklisting addresses

Functions

blacklist

Blacklists a user immediately (onlyOwner).

function blacklist(address user) external;

Parameters

unblacklist

Removes a user from the blacklist (onlyOwner).

function unblacklist(address user) external;

Parameters

unblacklist

Removes a user from the blacklist (onlyOwner).

function unblacklist(address user, uint256 index) external;

Parameters

getBlacklistedAddresses

Returns the list of currently blacklisted addresses.

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

Returns

isBlacklisted

Returns whether a user is currently blacklisted.

function isBlacklisted(address user) external view returns (bool);

Parameters

Returns

Events

Blacklisted

Emitted when a user is blacklisted

event Blacklisted(address indexed user);

Parameters

Unblacklisted

Emitted when a user is removed from blacklist

event Unblacklisted(address indexed user);

Parameters

Errors

Blacklister_AlreadyBlacklisted

Error thrown when address is already blacklisted

error Blacklister_AlreadyBlacklisted();

Blacklister_NotBlacklisted

Error thrown when address is not blacklisted

error Blacklister_NotBlacklisted();

Blacklister_InvalidRoles

Error thrown when roles contract is invalid

error Blacklister_InvalidRoles();

Blacklister_NotAllowed

Error thrown when caller is not authorized

error Blacklister_NotAllowed();

IBridge

Git Source

Title: IBridge

Author: Merge Layers Inc.

Interface for rebalancing bridge implementations

Functions

sendMsg

rebalance through bridge

function sendMsg(
    uint256 _extractedAmount,
    address _market,
    uint32 _dstChainId,
    address _token,
    bytes calldata _message,
    bytes calldata _bridgeData
) external payable;

Parameters

getFee

computes fee for bridge operation

function getFee(uint32 _dstChainId, bytes calldata _message, bytes calldata _bridgeData)
    external
    view
    returns (uint256);

Parameters

Returns

IDefaultAdapter

Git Source

Title: IDefaultAdapter

Author: Merge Layers Inc.

Default price adapter interface used for oracle feeds

Functions

decimals

Returns the decimals for the price feed

function decimals() external view returns (uint8);

Returns

latestRoundData

Returns the latest round data from the feed

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

Returns

latestAnswer

Returns the latest answer

function latestAnswer() external view returns (int256);

Returns

latestTimestamp

Returns the latest timestamp

function latestTimestamp() external view returns (uint256);

Returns

Structs

PriceConfig

struct PriceConfig {
    address defaultFeed; // chainlink & eOracle
    string toSymbol;
    uint256 underlyingDecimals;
}

IGasFeesHelper

Git Source

Title: IGasFeesHelper

Author: Merge Layers Inc.

Interface for retrieving per-chain gas fee configuration

Functions

gasFees

Returns the gas fee for a destination chain

function gasFees(uint32 dstChainId) external view returns (uint256 fee);

Parameters

Returns

IInterestRateModel

Git Source

Title: IInterestRateModel

Author: Merge Layers Inc.

Interface for the interest rate contracts

Functions

isInterestRateModel

Should return true

function isInterestRateModel() external view returns (bool);

Returns

blocksPerYear

The approximate number of blocks per year that is assumed by the interest rate model

function blocksPerYear() external view returns (uint256);

Returns

multiplierPerBlock

The multiplier of utilization rate that gives the slope of the interest rate

function multiplierPerBlock() external view returns (uint256);

Returns

baseRatePerBlock

The base interest rate which is the y-intercept when utilization rate is 0

function baseRatePerBlock() external view returns (uint256);

Returns

jumpMultiplierPerBlock

The multiplierPerBlock after hitting a specified utilization point

function jumpMultiplierPerBlock() external view returns (uint256);

Returns

kink

The utilization point at which the jump multiplier is applied

function kink() external view returns (uint256);

Returns

name

A name for user-friendliness, e.g. WBTC

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

Returns

getBorrowRate

Returns the current borrow rate per block for the market

function getBorrowRate(uint256 cash, uint256 borrows, uint256 reserves) external view returns (uint256);

Parameters

Returns

getSupplyRate

Returns the current supply rate per block for the market

function getSupplyRate(uint256 cash, uint256 borrows, uint256 reserves, uint256 reserveFactorMantissa)
    external
    view
    returns (uint256);

Parameters

Returns

utilizationRate

Calculates the utilization rate of the market

function utilizationRate(uint256 cash, uint256 borrows, uint256 reserves) external pure returns (uint256);

Parameters

Returns

Events

NewInterestParams

Emitted when interest rate parameters are updated

event NewInterestParams(
    uint256 baseRatePerBlock, uint256 multiplierPerBlock, uint256 jumpMultiplierPerBlock, uint256 kink
);

Parameters

BlocksPerYearUpdated

Emitted when blocks per year is updated

event BlocksPerYearUpdated(uint256 blocksPerYear);

Parameters

Errors

JumpRateModelV4_MultiplierNotValid

Error thrown when multiplier is not valid

error JumpRateModelV4_MultiplierNotValid();

JumpRateModelV4_InputNotValid

Error thrown when input is not valid

error JumpRateModelV4_InputNotValid();

JumpRateModelV4_ZeroValueNotAllowed

Error thrown when zero value is not allowed

error JumpRateModelV4_ZeroValueNotAllowed();

IOperatorData

Git Source

Title: Operator storage structures

Author: Merge Layers Inc.

Data definitions used by Operator contracts

Structs

Market

struct Market {
    // Whether or not this market is listed
    bool isListed;
    //  Multiplier representing the most one can borrow against their collateral in this market.
    //  For instance, 0.9 to allow borrowing 90% of collateral value.
    //  Must be between 0 and 1, and stored as a mantissa.
    uint256 collateralFactorMantissa;
    // Per-market mapping of "accounts in this asset"
    mapping(address => bool) accountMembership;
}

IOperatorDefender

Git Source

Title: Operator defender interface

Author: Merge Layers Inc.

Hooks for Operator validation logic

Functions

beforeRebalancing

Checks if the account should be allowed to rebalance tokens

function beforeRebalancing(address mToken) external;

Parameters

beforeMTokenBorrow

Checks if the account should be allowed to borrow the underlying asset of the given market

function beforeMTokenBorrow(address mToken, address borrower, uint256 borrowAmount) external;

Parameters

checkOutflowVolumeLimit

Checks if new used amount is within the limits of the outflow volume limit

Sender must be a listed market

function checkOutflowVolumeLimit(uint256 amount) external;

Parameters

beforeMTokenTransfer

Checks if the account should be allowed to transfer tokens in the given market

function beforeMTokenTransfer(address mToken, address src, address dst, uint256 transferTokens) external;

Parameters

beforeMTokenRedeem

Checks if the account should be allowed to redeem tokens in the given market

function beforeMTokenRedeem(address mToken, address redeemer, uint256 redeemTokens) external view;

Parameters

beforeMTokenRepay

Checks if the account should be allowed to repay a borrow in the given market

function beforeMTokenRepay(address mToken, address borrower) external view;

Parameters

beforeMTokenLiquidate

Checks if the liquidation should be allowed to occur

function beforeMTokenLiquidate(
    address mTokenBorrowed,
    address mTokenCollateral,
    address borrower,
    uint256 repayAmount
) external view;

Parameters

beforeMTokenSeize

Checks if the seizing of assets should be allowed to occur

function beforeMTokenSeize(address mTokenCollateral, address mTokenBorrowed, address liquidator) external view;

Parameters

beforeMTokenMint

Checks if the account should be allowed to mint tokens in the given market

function beforeMTokenMint(address mToken, address minter, address receiver) external view;

Parameters

afterMTokenMint

Validates mint and reverts on rejection. May emit logs.

function afterMTokenMint(address mToken) external view;

Parameters

IOperator

Git Source

Title: Operator interface

Author: Merge Layers Inc.

Core Operator contract surface

Functions

userWhitelisted

Returns true/false for user

function userWhitelisted(address _user) external view returns (bool);

Parameters

Returns

limitPerTimePeriod

Should return outflow limit

function limitPerTimePeriod() external view returns (uint256);

Returns

cumulativeOutflowVolume

Should return outflow volume

function cumulativeOutflowVolume() external view returns (uint256);

Returns

lastOutflowResetTimestamp

Should return last reset time for outflow check

function lastOutflowResetTimestamp() external view returns (uint256);

Returns

outflowResetTimeWindow

Should return the outflow volume time window

function outflowResetTimeWindow() external view returns (uint256);

Returns

isPaused

Returns if operation is paused

function isPaused(address mToken, ImTokenOperationTypes.OperationType _type) external view returns (bool);

Parameters

Returns

rolesOperator

Roles

function rolesOperator() external view returns (IRoles);

Returns

blacklistOperator

Blacklist

function blacklistOperator() external view returns (IBlacklister);

Returns

oracleOperator

Oracle which gives the price of any given asset

function oracleOperator() external view returns (address);

Returns

closeFactorMantissa

Multiplier used to calculate the maximum repayAmount when liquidating a borrow

function closeFactorMantissa() external view returns (uint256);

Returns

liquidationIncentiveMantissa

Multiplier representing the discount on collateral that a liquidator receives

function liquidationIncentiveMantissa(address market) external view returns (uint256);

Parameters

Returns

isMarketListed

Returns true/false

function isMarketListed(address market) external view returns (bool);

Parameters

Returns

getAssetsIn

Returns the assets an account has entered

function getAssetsIn(address _user) external view returns (address[] memory mTokens);

Parameters

Returns

getAllMarkets

A list of all markets

function getAllMarkets() external view returns (address[] memory mTokens);

Returns

borrowCaps

Borrow caps enforced by borrowAllowed for each mToken address.

Defaults to zero which corresponds to unlimited borrowing.

function borrowCaps(address _mToken) external view returns (uint256);

Parameters

Returns

supplyCaps

Supply caps enforced by supplyAllowed for each mToken address.

Defaults to zero which corresponds to unlimited supplying.

function supplyCaps(address _mToken) external view returns (uint256);

Parameters

Returns

minBorrowSize

Supply caps enforced by supplyAllowed for each mToken address.

Defaults to zero which corresponds to unlimited borrowing.

function minBorrowSize(address _mToken) external view returns (uint256);

Parameters

Returns

checkMembership

Returns whether the given account is entered in the given asset

function checkMembership(address account, address mToken) external view returns (bool);

Parameters

Returns

getHypotheticalAccountLiquidity

Determine what the account liquidity would be if the given amounts were redeemed/borrowed

function getHypotheticalAccountLiquidity(
    address account,
    address mTokenModify,
    uint256 redeemTokens,
    uint256 borrowAmount
) external view returns (uint256 liquidity, uint256 shortfall);

Parameters

Returns

getUSDValueForAllMarkets

Returns USD value for all markets

function getUSDValueForAllMarkets() external view returns (uint256);

Returns

isDeprecated

Returns true if the given mToken market has been deprecated

All borrows in a deprecated mToken market can be immediately liquidated

function isDeprecated(address mToken) external view returns (bool);

Parameters

Returns

setPaused

Set pause for a specific operation

function setPaused(address mToken, ImTokenOperationTypes.OperationType _type, bool state) external;

Parameters

enterMarkets

Add assets to be included in account liquidity calculation

function enterMarkets(address[] calldata _mTokens) external;

Parameters

enterMarketsWithSender

Add asset (msg.sender) to be included in account liquidity calculation

function enterMarketsWithSender(address _account) external;

Parameters

exitMarket

Removes asset from sender's account liquidity calculation

Sender must not have an outstanding borrow balance in the asset, and must not be providing necessary collateral for an outstanding borrow.

function exitMarket(address _mToken) external;

Parameters

IOracleOperator

Git Source

Title: IOracleOperator

Author: Merge Layers Inc.

Oracle operator interface returning USD prices

Functions

getPrice

Get the price of a mToken asset

function getPrice(address mToken) external view returns (uint256);

Parameters

Returns

getUnderlyingPrice

Get the underlying price of a mToken asset

function getUnderlyingPrice(address mToken) external view returns (uint256);

Parameters

Returns

IOwnable

Git Source

Title: IOwnable

Author: Merge Layers Inc.

Minimal ownable interface

Functions

transferOwnership

Transfers ownership to a new owner

function transferOwnership(address newOwner) external;

Parameters

IPauser

Git Source

Inherits: ImTokenOperationTypes

Title: IPauser

Author: Merge Layers Inc.

Interface for pausing market operations

Functions

emergencyPauseMarket

Pauses all operations for a market

function emergencyPauseMarket(address _market) external;

Parameters

emergencyPauseMarketFor

Pauses a specific operation for a market

function emergencyPauseMarketFor(address _market, OperationType _pauseType) external;

Parameters

emergencyPauseAll

Pauses all operations for all registered markets

function emergencyPauseAll() external;

Events

PauseAll

Emitted when all markets are paused

event PauseAll();

MarketPaused

Emitted when a market is paused

event MarketPaused(address indexed market);

Parameters

MarketRemoved

Emitted when a market is removed

event MarketRemoved(address indexed market);

Parameters

MarketAdded

Emitted when a market is added

event MarketAdded(address indexed market, PausableType marketType);

Parameters

MarketPausedFor

Emitted when a specific operation is paused for a market

event MarketPausedFor(address indexed market, OperationType pauseType);

Parameters

Errors

Pauser_EntryNotFound

Error when entry is not found

error Pauser_EntryNotFound();

Pauser_NotAuthorized

Error when caller lacks authorization

error Pauser_NotAuthorized();

Pauser_AddressNotValid

Error when provided address is invalid

error Pauser_AddressNotValid();

Pauser_AlreadyRegistered

Error when market already registered

error Pauser_AlreadyRegistered();

Pauser_ContractNotEnabled

Error when contract is not enabled

error Pauser_ContractNotEnabled();

Structs

PausableContract

struct PausableContract {
    address market;
    PausableType contractType;
}

Enums

PausableType

enum PausableType {
    NonPausable,
    Host,
    Extension
}

IRebalanceMarket

Git Source

Title: IRebalanceMarket

Author: Merge Layers Inc.

Interface for markets supporting rebalancing extractions

Functions

extractForRebalancing

Extract amount to be used for rebalancing

function extractForRebalancing(uint256 amount) external;

Parameters

IRebalancer

Git Source

Title: IRebalancer

Author: Merge Layers Inc.

Interface for rebalancer operations and configuration

Functions

sendMsg

Sends a bridge message

function sendMsg(address bridge, address _market, uint256 _amount, Msg calldata _msg) external payable;

Parameters

nonce

Returns current nonce

function nonce() external view returns (uint256 currentNonce);

Returns

isBridgeWhitelisted

Returns if a bridge implementation is whitelisted

function isBridgeWhitelisted(address bridge) external view returns (bool whitelisted);

Parameters

Returns

isDestinationWhitelisted

Returns if a destination is whitelisted

function isDestinationWhitelisted(uint32 dstId) external view returns (bool whitelisted);

Parameters

Returns

isMarketWhitelisted

Returns if a market is whitelisted

function isMarketWhitelisted(address market) external view returns (bool whitelisted);

Parameters

Returns

Events

BridgeWhitelistedStatusUpdated

Emitted when bridge whitelist status changes

event BridgeWhitelistedStatusUpdated(address indexed bridge, bool status);

Parameters

MsgSent

Emitted when a message is sent through a bridge

event MsgSent(
    address indexed bridge, uint32 indexed dstChainId, address indexed token, bytes message, bytes bridgeData
);

Parameters

EthSaved

Emitted when ETH is saved back to treasury

event EthSaved(uint256 amount);

Parameters

MaxTransferSizeUpdated

Emitted when max transfer size is updated

event MaxTransferSizeUpdated(uint32 indexed dstChainId, address indexed token, uint256 newLimit);

Parameters

MinTransferSizeUpdated

Emitted when min transfer size is updated

event MinTransferSizeUpdated(uint32 indexed dstChainId, address indexed token, uint256 newLimit);

Parameters

DestinationWhitelistedStatusUpdated

Emitted when destination whitelist status changes

event DestinationWhitelistedStatusUpdated(uint32 indexed dstChainId, bool status);

Parameters

AllowedListUpdated

Emitted when allowed list is updated

event AllowedListUpdated(address[] list, bool status);

Parameters

TokensSaved

Emitted when tokens are rescued

event TokensSaved(address indexed token, address indexed market, uint256 amount);

Parameters

AllowedTokensUpdated

Emitted when allowed tokens list is updated for a bridge

event AllowedTokensUpdated(address indexed bridge, bool status, address[] list);

Parameters

MarketListUpdated

Emitted when market list is updated

event MarketListUpdated(address[] list, bool status);

Parameters

Errors

Rebalancer_NotAuthorized

Error thrown when caller not authorized

error Rebalancer_NotAuthorized();

Rebalancer_MarketNotValid

Error thrown when market is not valid

error Rebalancer_MarketNotValid();

Rebalancer_RequestNotValid

Error thrown when request is not valid

error Rebalancer_RequestNotValid();

Rebalancer_AddressNotValid

Error thrown when address is not valid

error Rebalancer_AddressNotValid();

Rebalancer_BridgeNotWhitelisted

Error thrown when bridge is not whitelisted

error Rebalancer_BridgeNotWhitelisted();

Rebalancer_TransferSizeExcedeed

Error thrown when transfer size exceeds maximum

error Rebalancer_TransferSizeExcedeed();

Rebalancer_TransferSizeMinNotMet

Error thrown when transfer size below minimum

error Rebalancer_TransferSizeMinNotMet();

Rebalancer_DestinationNotWhitelisted

Error thrown when destination not whitelisted

error Rebalancer_DestinationNotWhitelisted();

Rebalancer_UnderlyingNotAllowedForBridge

Error thrown when underlying token not allowed for bridge

error Rebalancer_UnderlyingNotAllowedForBridge();

Structs

Msg

struct Msg {
    uint32 dstChainId;
    address token;
    bytes message;
    bytes bridgeData;
}

IRewardDistributorData

Git Source

Title: IRewardDistributorData

Author: Merge Layers Inc.

Storage structs for reward distributor

Structs

RewardMarketState

struct RewardMarketState {
    /// @notice The supply speed for each market
    uint256 supplySpeed;
    /// @notice The supply index for each market
    uint224 supplyIndex;
    /// @notice The last block timestamp that Reward accrued for supply
    uint32 supplyBlock;
    /// @notice The borrow speed for each market
    uint256 borrowSpeed;
    /// @notice The borrow index for each market
    uint224 borrowIndex;
    /// @notice The last block timestamp that Reward accrued for borrow
    uint32 borrowBlock;
}

RewardAccountState

struct RewardAccountState {
    /// @notice The supply index for each market as of the last time the account accrued Reward
    mapping(address => uint256) supplierIndex;
    /// @notice The borrow index for each market as of the last time the account accrued Reward
    mapping(address => uint256) borrowerIndex;
    /// @notice Accrued Reward but not yet transferred
    uint256 rewardAccrued;
}

IRewardDistributor

Git Source

Title: IRewardDistributor

Author: Merge Layers Inc.

Interface for reward distribution operations

Functions

notifySupplyIndex

Updates supply indices for all reward tokens on a market

function notifySupplyIndex(address mToken) external;

Parameters

notifyBorrowIndex

Updates borrow indices for all reward tokens on a market

function notifyBorrowIndex(address mToken) external;

Parameters

notifySupplier

Notifies supplier

function notifySupplier(address mToken, address supplier) external;

Parameters

notifyBorrower

Notifies borrower

function notifyBorrower(address mToken, address borrower) external;

Parameters

claim

Claim tokens for holders

function claim(address[] memory holders) external;

Parameters

operator

The operator that rewards are distributed to

function operator() external view returns (address operatorAddress);

Returns

isRewardToken

Flag to check if reward token added before

function isRewardToken(address _token) external view returns (bool isRewardTokenAdded);

Parameters

Returns

getRewardTokens

Added reward tokens

function getRewardTokens() external view returns (address[] memory rewardTokens);

Returns

getBlockTimestamp

Get block timestamp

function getBlockTimestamp() external view returns (uint32 timestamp);

Returns

Events

RewardAccrued

Emitted when reward is accrued for a user

event RewardAccrued(address indexed rewardToken, address indexed user, uint256 deltaAccrued, uint256 totalAccrued);

Parameters

RewardGranted

Emitted when reward is granted to a user

event RewardGranted(address indexed rewardToken, address indexed user, uint256 amount);