About Malda Protocol

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

About this repository

This repository contains the source for the onchain Solidity components required to run Malda, the first DeFi protocol built in the Risc Zero zkVM. These critical components serve multiple function within the Malda application:

• Secure protocol ledger onchain
• Execute UserOps leveraging proofs generated mwith the malda-zk-coprocessor component
• Provides an entry point for users from multiple underlying chains leveraging mTokenGateway contract

Contents

• Operator
• OperatorStorage

Operator

Git Source

Inherits: OperatorStorage, ImTokenOperationTypes, OwnableUpgradeable

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor();

initialize

function initialize(address _rolesOperator, address _rewardDistributor, address _admin) public initializer;

onlyAllowedUser

modifier onlyAllowedUser(address user);

setWhitelistedUser

Sets user whitelist status

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

Parameters

enableWhitelist

Enable user whitelist

function enableWhitelist() external onlyOwner;

disableWhitelist

Disable user whitelist

function disableWhitelist() external onlyOwner;

setRolesOperator

Sets a new Operator for the market

Admin function to set a new operator

function setRolesOperator(address _roles) external onlyOwner;

setPriceOracle

Sets a new price oracle

Admin function to set a new price oracle

function setPriceOracle(address newOracle) external onlyOwner;

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 volule limit

function checkOutflowVolumeLimit(uint256 amount) external;

Parameters

setMarketBorrowCaps

Set the given borrow caps for the given mToken markets. Borrowing that brings total borrows to or above borrow cap will revert.

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

Parameters

setMarketSupplyCaps

Set the given supply caps for the given mToken markets. Supplying that brings total supply to or above supply cap will revert.

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

Parameters

setPaused

Set pause for a specific operation

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

Parameters

setRewardDistributor

Admin function to change the Reward Distributor

function setRewardDistributor(address newRewardDistributor) external onlyOwner;

Parameters

isOperator

Should return true

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

isPaused

Returns if operation is paused

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

Parameters

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

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

isMarketListed

Returns true/false

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

getAccountLiquidity

Determine the current account liquidity wrt collateral requirements

function getAccountLiquidity(address account) public view returns (uint256, uint256);

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

liquidateCalculateSeizeTokens

Calculate number of tokens of collateral asset to seize given an underlying amount

Used in liquidation (called in mTokenBorrowed.liquidate)

function liquidateCalculateSeizeTokens(address mTokenBorrowed, address mTokenCollateral, uint256 actualRepayAmount)
    external
    view
    returns (uint256);

Parameters

Returns

enterMarkets

Add assets to be included in account liquidity calculation

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

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, or be providing necessary collateral for an outstanding borrow.

function exitMarket(address _mToken) external override;

Parameters

claimMalda

Claim all the MALDA accrued by holder in all markets

function claimMalda(address holder) external override;

Parameters

claimMalda

Claim all the MALDA accrued by holder in the specified markets

function claimMalda(address holder, address[] memory mTokens) external override;

Parameters

claimMalda

Claim all MALDA accrued by the holders

function claimMalda(address[] memory holders, address[] memory mTokens, bool borrowers, bool suppliers)
    external
    override;

Parameters

getUSDValueForAllMarkets

Returns USD value for all markets

function getUSDValueForAllMarkets() external view returns (uint256);

beforeWithdrawOnExtension

Checks whitelist status on withdrawOnExtension

function beforeWithdrawOnExtension(address user) external view onlyAllowedUser(user);

Parameters

beforeBorrowOnExtension

Checks whitelist status on borrowOnExtension

function beforeBorrowOnExtension(address user) external view onlyAllowedUser(user);

Parameters

beforeRebalancing

Checks if the account should be allowed to rebalance tokens

function beforeRebalancing(address mToken) external view override;

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;

Parameters

beforeMTokenMint

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

function beforeMTokenMint(address mToken, address minter) external override 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
    override
    onlyAllowedUser(redeemer);

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

Parameters

beforeMTokenRepay

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

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

Parameters

beforeMTokenLiquidate

Checks if the liquidation should be allowed to occur

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

Parameters

beforeMTokenSeize

Checks if the seizing of assets should be allowed to occur

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

Parameters

_convertMarketAmountToUSDValue

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

_activateMarket

function _activateMarket(address _mToken, address borrower) private;

_beforeRedeem

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

_getHypotheticalAccountLiquidity

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

_updateMaldaSupplyIndex

Notify reward distributor for supply index update

function _updateMaldaSupplyIndex(address mToken) private;

Parameters

_updateMaldaBorrowIndex

Notify reward distributor for borrow index update

function _updateMaldaBorrowIndex(address mToken) private;

Parameters

_distributeSupplierMalda

Notify reward distributor for supplier update

function _distributeSupplierMalda(address mToken, address supplier) private;

Parameters

_distributeBorrowerMalda

Notify reward distributor for borrower update

Borrowers will not begin to accrue until after the first interaction with the protocol.

function _distributeBorrowerMalda(address mToken, address borrower) private;

Parameters

_claim

function _claim(address[] memory holders, address[] memory mTokens, bool borrowers, bool suppliers) private;

_isDeprecated

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

OperatorStorage

Git Source

Inherits: IOperator, IOperatorDefender, ExponentialNoError

State Variables

rolesOperator

Roles manager

IRoles public rolesOperator;

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

Multiplier representing the discount on collateral that a liquidator receives

mapping(address => uint256) public liquidationIncentiveMantissa;

accountAssets

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

mapping(address => address[]) public accountAssets;

markets

Official mapping of mTokens -> Market metadata

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

mapping(address => IOperatorData.Market) public markets;

allMarkets

A list of all markets

address[] public allMarkets;

borrowCaps

Borrow caps enforced by borrowAllowed for each mToken address. Defaults to zero which corresponds to unlimited borrowing.

mapping(address => uint256) public borrowCaps;

supplyCaps

Supply caps enforced by supplyAllowed for each mToken address. Defaults to zero which corresponds to unlimited supplying.

mapping(address => uint256) public supplyCaps;

rewardDistributor

Reward Distributor to markets supply and borrow (including protocol token)

address public rewardDistributor;

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

Returns true/false for user

mapping(address => bool) public userWhitelisted;

whitelistEnabled

bool public whitelistEnabled;

_paused

mapping(address => mapping(ImTokenOperationTypes.OperationType => bool)) internal _paused;

CLOSE_FACTOR_MIN_MANTISSA

uint256 internal constant CLOSE_FACTOR_MIN_MANTISSA = 0.05e18;

CLOSE_FACTOR_MAX_MANTISSA

uint256 internal constant CLOSE_FACTOR_MAX_MANTISSA = 0.9e18;

COLLATERAL_FACTOR_MAX_MANTISSA

uint256 internal constant COLLATERAL_FACTOR_MAX_MANTISSA = 0.9e18;

Events

UserWhitelisted

Emitted when user whitelist status is changed

event UserWhitelisted(address indexed user, bool state);

WhitelistEnabled

event WhitelistEnabled();

WhitelistDisabled

event WhitelistDisabled();

ActionPaused

Emitted when pause status is changed

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

NewRewardDistributor

Emitted when reward distributor is changed

event NewRewardDistributor(address indexed oldRewardDistributor, address indexed newRewardDistributor);

NewBorrowCap

Emitted when borrow cap for a mToken is changed

event NewBorrowCap(address indexed mToken, uint256 newBorrowCap);

NewSupplyCap

Emitted when supply cap for a mToken is changed

event NewSupplyCap(address indexed mToken, uint256 newBorrowCap);

MarketListed

Emitted when an admin supports a market

event MarketListed(address mToken);

MarketEntered

Emitted when an account enters a market

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

MarketExited

Emitted when an account exits a market

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

NewCloseFactor

Emitted Emitted when close factor is changed by admin

event NewCloseFactor(uint256 oldCloseFactorMantissa, uint256 newCloseFactorMantissa);

NewCollateralFactor

Emitted when a collateral factor is changed by admin

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

NewLiquidationIncentive

Emitted when liquidation incentive is changed by admin

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

NewPriceOracle

Emitted when price oracle is changed

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

NewRolesOperator

Event emitted when rolesOperator is changed

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

OutflowLimitUpdated

Event emitted when outflow limit is updated

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

OutflowTimeWindowUpdated

Event emitted when outflow reset time window is updated

event OutflowTimeWindowUpdated(uint256 oldWindow, uint256 newWindow);

OutflowVolumeReset

Event emitted when outflow volume has been reset

event OutflowVolumeReset();

Errors

Operator_Paused

error Operator_Paused();

Operator_Mismatch

error Operator_Mismatch();

Operator_OnlyAdmin

error Operator_OnlyAdmin();

Operator_EmptyPrice

error Operator_EmptyPrice();

Operator_WrongMarket

error Operator_WrongMarket();

Operator_InvalidInput

error Operator_InvalidInput();

Operator_AssetNotFound

error Operator_AssetNotFound();

Operator_RepayingTooMuch

error Operator_RepayingTooMuch();

Operator_OnlyAdminOrRole

error Operator_OnlyAdminOrRole();

Operator_MarketNotListed

error Operator_MarketNotListed();

Operator_PriceFetchFailed

error Operator_PriceFetchFailed();

Operator_SenderMustBeToken

error Operator_SenderMustBeToken();

Operator_UserNotWhitelisted

error Operator_UserNotWhitelisted();

Operator_MarketSupplyReached

error Operator_MarketSupplyReached();

Operator_RepayAmountNotValid

error Operator_RepayAmountNotValid();

Operator_MarketAlreadyListed

error Operator_MarketAlreadyListed();

Operator_OutflowVolumeReached

error Operator_OutflowVolumeReached();

Operator_InvalidRolesOperator

error Operator_InvalidRolesOperator();

Operator_InsufficientLiquidity

error Operator_InsufficientLiquidity();

Operator_MarketBorrowCapReached

error Operator_MarketBorrowCapReached();

Operator_InvalidCollateralFactor

error Operator_InvalidCollateralFactor();

Operator_InvalidRewardDistributor

error Operator_InvalidRewardDistributor();

Operator_OracleUnderlyingFetchError

error Operator_OracleUnderlyingFetchError();

Operator_Deactivate_MarketBalanceOwed

error Operator_Deactivate_MarketBalanceOwed();

Structs

AccountLiquidityLocalVars

Local vars for avoiding stack-depth limits in calculating account liquidity. Note that mTokenBalance is the number of mTokens the account owns in the market, whereas borrowBalance is the amount of underlying that the account has borrowed.

struct AccountLiquidityLocalVars {
    uint256 sumCollateral;
    uint256 sumBorrowPlusEffects;
    uint256 mTokenBalance;
    uint256 borrowBalance;
    uint256 exchangeRateMantissa;
    uint256 oraclePriceMantissa;
    Exp collateralFactor;
    Exp exchangeRate;
    Exp oraclePrice;
    Exp tokensToDenom;
}

Contents

• JumpRateModelV4

JumpRateModelV4

Git Source

Inherits: IInterestRateModel, Ownable

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 baseRatePerYear,
    uint256 multiplierPerYear,
    uint256 jumpMultiplierPerYear,
    uint256 kink_,
    address owner_,
    string memory name_
) Ownable(owner_);

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

isInterestRateModel

Should return true

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

utilizationRate

Calculates the utilization rate of the market

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

Parameters

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

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

_updateJumpRateModel

Internal function to update the parameters of the interest rate model

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

Parameters

Errors

JumpRateModelV4_MultiplierNotValid

error JumpRateModelV4_MultiplierNotValid();

Contents

• external
• IBridge
• IDefaultAdapter
• 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

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

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 {
    address depositor;
    address recipient;
    address exclusiveRelayer;
    address inputToken;
    address outputToken;
    uint256 inputAmount;
    uint256 outputAmount;
    uint256 originChainId;
    uint32 depositId;
    uint32 fillDeadline;
    uint32 exclusivityDeadline;
    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,
    ReplacedSlowFill,
    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

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

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;
    bytes32 to;
    uint256 amountLD;
    uint256 minAmountLD;
    bytes extraOptions;
    bytes composeMsg;
    bytes oftCmd;
}

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;
    uint256 maxAmountLD;
}

OFTReceipt

Git Source

Struct representing OFT receipt information.

struct OFTReceipt {
    uint256 amountSentLD;
    uint256 amountReceivedLD;
}

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;
    string description;
}

ILayerZeroOFT

Git Source

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(
    bytes32 indexed guid, uint32 dstEid, address indexed fromAddress, uint256 amountSentLD, uint256 amountReceivedLD
);

OFTReceived

event OFTReceived(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);

IBridge

Git Source

Functions

getFee

computes fee for bridge operation

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

Parameters

sendMsg

rebalance through bridge

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

Parameters

IDefaultAdapter

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

latestAnswer

function latestAnswer() external view returns (int256);

latestTimestamp

function latestTimestamp() external view returns (uint256);

Structs

PriceConfig

struct PriceConfig {
    address defaultFeed;
    string toSymbol;
    uint256 underlyingDecimals;
}

IInterestRateModel

Git Source

Interface for the interest rate contracts

Functions

isInterestRateModel

Should return true

function isInterestRateModel() external view returns (bool);

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

utilizationRate

Calculates the utilization rate of the market

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

Parameters

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

Events

NewInterestParams

Emitted when interest rate parameters are updated

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

Parameters

IOperatorData

Git Source

Structs

Market

struct Market {
    bool isListed;
    uint256 collateralFactorMantissa;
    mapping(address => bool) accountMembership;
    bool isMalded;
}

IOperatorDefender

Git Source

Functions

beforeRebalancing

Checks if the account should be allowed to rebalance tokens

function beforeRebalancing(address mToken) 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

beforeMTokenMint

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

function beforeMTokenMint(address mToken, address minter) external;

Parameters

afterMTokenMint

Validates mint and reverts on rejection. May emit logs.

function afterMTokenMint(address mToken) external view;

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;

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

beforeMTokenRepay

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

function beforeMTokenRepay(address mToken, address borrower) external;

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, address borrower)
    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

beforeWithdrawOnExtension

Checks whitelist status on withdrawOnExtension

function beforeWithdrawOnExtension(address user) external view;

Parameters

beforeBorrowOnExtension

Checks whitelist status on borrowOnExtension

function beforeBorrowOnExtension(address user) external view;

Parameters

IOperator

Git Source

Functions

userWhitelisted

Returns true/false for user

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

isOperator

Should return true

function isOperator() external view returns (bool);

limitPerTimePeriod

Should return outflow limit

function limitPerTimePeriod() external view returns (uint256);

cumulativeOutflowVolume

Should return outflow volume

function cumulativeOutflowVolume() external view returns (uint256);

lastOutflowResetTimestamp

Should return last reset time for outflow check

function lastOutflowResetTimestamp() external view returns (uint256);

outflowResetTimeWindow

Should return the outflow volume time window

function outflowResetTimeWindow() external view returns (uint256);

isPaused

Returns if operation is paused

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

Parameters

rolesOperator

Roles manager

function rolesOperator() external view returns (IRoles);

oracleOperator

Oracle which gives the price of any given asset

function oracleOperator() external view returns (address);

closeFactorMantissa

Multiplier used to calculate the maximum repayAmount when liquidating a borrow

function closeFactorMantissa() external view returns (uint256);

liquidationIncentiveMantissa

Multiplier representing the discount on collateral that a liquidator receives

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

isMarketListed

Returns true/false

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

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

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

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

rewardDistributor

Reward Distributor to markets supply and borrow (including protocol token)

function rewardDistributor() external view returns (address);

checkMembership

Returns whether the given account is entered in the given asset

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

Parameters

Returns

getAccountLiquidity

Determine the current account liquidity wrt collateral requirements

function getAccountLiquidity(address account) external view returns (uint256, uint256);

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

getUSDValueForAllMarkets

Returns USD value for all markets

function getUSDValueForAllMarkets() external view returns (uint256);

liquidateCalculateSeizeTokens

Calculate number of tokens of collateral asset to seize given an underlying amount

Used in liquidation (called in mTokenBorrowed.liquidate)

function liquidateCalculateSeizeTokens(address mTokenBorrowed, address mTokenCollateral, uint256 actualRepayAmount)
    external
    view
    returns (uint256);

Parameters

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

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, or be providing necessary collateral for an outstanding borrow.

function exitMarket(address _mToken) external;

Parameters

claimMalda

Claim all the MALDA accrued by holder in all markets

function claimMalda(address holder) external;

Parameters

claimMalda

Claim all the MALDA accrued by holder in the specified markets

function claimMalda(address holder, address[] memory mTokens) external;

Parameters

claimMalda

Claim all MALDA accrued by the holders

function claimMalda(address[] memory holders, address[] memory mTokens, bool borrowers, bool suppliers) external;

Parameters

IOracleOperator

Git Source

Prices are returned in USD

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

Functions

transferOwnership

function transferOwnership(address newOwner) external;

IPauser

Git Source

Inherits: ImTokenOperationTypes

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

event PauseAll();

MarketPaused

event MarketPaused(address indexed market);

MarketRemoved

event MarketRemoved(address indexed market);

MarketAdded

event MarketAdded(address indexed market, PausableType marketType);

MarketPausedFor

event MarketPausedFor(address indexed market, OperationType pauseType);

Errors

Pauser_EntryNotFound

error Pauser_EntryNotFound();

Pauser_NotAuthorized

error Pauser_NotAuthorized();

Pauser_AddressNotValid

error Pauser_AddressNotValid();

Pauser_AlreadyRegistered

error Pauser_AlreadyRegistered();

Pauser_ContractNotEnabled

error Pauser_ContractNotEnabled();

Structs

PausableContract

struct PausableContract {
    address market;
    PausableType contractType;
}

Enums

PausableType

enum PausableType {
    NonPausable,
    Host,
    Extension
}

IRebalanceMarket

Git Source

Functions

extractForRebalancing

function extractForRebalancing(uint256 amount) external;

IRebalancer

Git Source

Functions

nonce

returns current nonce

function nonce() external view returns (uint256);

isBridgeWhitelisted

returns if a bridge implementation is whitelisted

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

isDestinationWhitelisted

returns if a destination is whitelisted

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

sendMsg

sends a bridge message

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

Parameters

Events

BridgeWhitelistedStatusUpdated

event BridgeWhitelistedStatusUpdated(address indexed bridge, bool status);

MsgSent

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

EthSaved

event EthSaved(uint256 amount);

MaxTransferSizeUpdated

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

MinTransferSizeUpdated

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

DestinationWhitelistedStatusUpdated

event DestinationWhitelistedStatusUpdated(uint32 indexed dstChainId, bool status);

AllowedListUpdated

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

Errors

Rebalancer_NotAuthorized

error Rebalancer_NotAuthorized();

Rebalancer_MarketNotValid

error Rebalancer_MarketNotValid();

Rebalancer_RequestNotValid

error Rebalancer_RequestNotValid();

Rebalancer_AddressNotValid

error Rebalancer_AddressNotValid();

Rebalancer_BridgeNotWhitelisted

error Rebalancer_BridgeNotWhitelisted();

Rebalancer_TransferSizeExcedeed

error Rebalancer_TransferSizeExcedeed();

Rebalancer_TransferSizeMinNotMet

error Rebalancer_TransferSizeMinNotMet();

Rebalancer_DestinationNotWhitelisted

error Rebalancer_DestinationNotWhitelisted();

Structs

Msg

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

IRewardDistributorData

Git Source

Structs

RewardMarketState

struct RewardMarketState {
    uint256 supplySpeed;
    uint224 supplyIndex;
    uint32 supplyBlock;
    uint256 borrowSpeed;
    uint224 borrowIndex;
    uint32 borrowBlock;
}

RewardAccountState

struct RewardAccountState {
    mapping(address => uint256) supplierIndex;
    mapping(address => uint256) borrowerIndex;
    uint256 rewardAccrued;
}

IRewardDistributor

Git Source

Functions

operator

The operator that rewards are distributed to

function operator() external view returns (address);

isRewardToken

Flag to check if reward token added before

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

Parameters

getRewardTokens

Added reward tokens

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

getBlockTimestamp

Get block timestamp

function getBlockTimestamp() external view returns (uint32);

notifySupplyIndex

Notifies supply index

function notifySupplyIndex(address mToken) external;

notifyBorrowIndex

Notifies borrow index

function notifyBorrowIndex(address mToken) external;

notifySupplier

Notifies supplier

function notifySupplier(address mToken, address supplier) external;

notifyBorrower

Notifies borrower

function notifyBorrower(address mToken, address borrower) external;

claim

Claim tokens for `holders

function claim(address[] memory holders) external;

Parameters

Events

RewardAccrued

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

RewardGranted

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

SupplySpeedUpdated

event SupplySpeedUpdated(address indexed rewardToken, address indexed mToken, uint256 supplySpeed);

BorrowSpeedUpdated

event BorrowSpeedUpdated(address indexed rewardToken, address indexed mToken, uint256 borrowSpeed);

OperatorSet

event OperatorSet(address indexed oldOperator, address indexed newOperator);

WhitelistedToken

event WhitelistedToken(address indexed token);

SupplyIndexNotified

event SupplyIndexNotified(address indexed rewardToken, address indexed mToken);

BorrowIndexNotified

event BorrowIndexNotified(address indexed rewardToken, address indexed mToken);

IRoles

Git Source

Functions

REBALANCER

Returns REBALANCER role

function REBALANCER() external view returns (bytes32);

REBALANCER_EOA

Returns REBALANCER_EOA role

function REBALANCER_EOA() external view returns (bytes32);

GUARDIAN_PAUSE

Returns GUARDIAN_PAUSE role

function GUARDIAN_PAUSE() external view returns (bytes32);

GUARDIAN_BRIDGE

Returns GUARDIAN_BRIDGE role

function GUARDIAN_BRIDGE() external view returns (bytes32);

GUARDIAN_BORROW_CAP

Returns GUARDIAN_BORROW_CAP role

function GUARDIAN_BORROW_CAP() external view returns (bytes32);

GUARDIAN_SUPPLY_CAP

Returns GUARDIAN_SUPPLY_CAP role

function GUARDIAN_SUPPLY_CAP() external view returns (bytes32);

GUARDIAN_RESERVE

Returns GUARDIAN_RESERVE role

function GUARDIAN_RESERVE() external view returns (bytes32);

PROOF_FORWARDER

Returns PROOF_FORWARDER role

function PROOF_FORWARDER() external view returns (bytes32);

PROOF_BATCH_FORWARDER

Returns PROOF_BATCH_FORWARDER role

function PROOF_BATCH_FORWARDER() external view returns (bytes32);

SEQUENCER

Returns SEQUENCER role

function SEQUENCER() external view returns (bytes32);

PAUSE_MANAGER

Returns PAUSE_MANAGER role

function PAUSE_MANAGER() external view returns (bytes32);

CHAINS_MANAGER

Returns CHAINS_MANAGER role

function CHAINS_MANAGER() external view returns (bytes32);

GUARDIAN_ORACLE

Returns GUARDIAN_ORACLE role

function GUARDIAN_ORACLE() external view returns (bytes32);

isAllowedFor

Returns allowance status for a contract and a role

function isAllowedFor(address _contract, bytes32 _role) external view returns (bool);

Parameters

Errors

Roles_InputNotValid

error Roles_InputNotValid();

ImErc20

Git Source

Functions

mint

Sender supplies assets into the market and receives mTokens in exchange

Accrues interest whether or not the operation succeeds, unless reverted

function mint(uint256 mintAmount, address receiver, uint256 minAmountOut) external;

Parameters

redeem

Sender redeems mTokens in exchange for the underlying asset

Accrues interest whether or not the operation succeeds, unless reverted

function redeem(uint256 redeemTokens) external;

Parameters

redeemUnderlying

Sender redeems mTokens in exchange for a specified amount of underlying asset

Accrues interest whether or not the operation succeeds, unless reverted

function redeemUnderlying(uint256 redeemAmount) external;

Parameters

borrow

Sender borrows assets from the protocol to their own address

function borrow(uint256 borrowAmount) external;

Parameters

repay

Sender repays their own borrow

function repay(uint256 repayAmount) external returns (uint256);

Parameters

repayBehalf

Sender repays a borrow belonging to borrower

function repayBehalf(address borrower, uint256 repayAmount) external returns (uint256);

Parameters

liquidate

The sender liquidates the borrowers collateral. The collateral seized is transferred to the liquidator.

function liquidate(address borrower, uint256 repayAmount, address mTokenCollateral) external;

Parameters

addReserves

The sender adds to reserves.

function addReserves(uint256 addAmount) external;

Parameters

ImErc20Host

Git Source

Functions

isCallerAllowed

Returns if a caller is allowed for sender

function isCallerAllowed(address sender, address caller) external view returns (bool);

getProofData

Returns the proof data journal

function getProofData(address user, uint32 dstId) external view returns (uint256, uint256);

mintMigration

Mints mTokens during migration without requiring underlying transfer

function mintMigration(uint256 amount, uint256 minAmount, address receiver) external;

Parameters

borrowMigration

Borrows from market for a specific borrower and not msg.sender

function borrowMigration(uint256 amount, address borrower, address receiver) external;

Parameters

extractForRebalancing

Extract amount to be used for rebalancing operation

function extractForRebalancing(uint256 amount) external;

Parameters

updateAllowedCallerStatus

Set caller status for msg.sender

function updateAllowedCallerStatus(address caller, bool status) external;

Parameters

liquidateExternal

Mints tokens after external verification

function liquidateExternal(
    bytes calldata journalData,
    bytes calldata seal,
    address[] calldata userToLiquidate,
    uint256[] calldata liquidateAmount,
    address[] calldata collateral,
    address receiver
) external;

Parameters

mintExternal

Mints tokens after external verification

function mintExternal(
    bytes calldata journalData,
    bytes calldata seal,
    uint256[] calldata mintAmount,
    uint256[] calldata minAmountsOut,
    address receiver
) external;

Parameters

repayExternal

Repays tokens after external verification

function repayExternal(
    bytes calldata journalData,
    bytes calldata seal,
    uint256[] calldata repayAmount,
    address receiver
) external;

Parameters

withdrawOnExtension

Initiates a withdraw operation

function withdrawOnExtension(uint256 amount, uint32 dstChainId) external payable;

Parameters

borrowOnExtension

Initiates a withdraw operation

function borrowOnExtension(uint256 amount, uint32 dstChainId) external payable;

Parameters

Events

AllowedCallerUpdated

Emitted when a user updates allowed callers

event AllowedCallerUpdated(address indexed sender, address indexed caller, bool status);

mErc20Host_ChainStatusUpdated

Emitted when a chain id whitelist status is updated

event mErc20Host_ChainStatusUpdated(uint32 indexed chainId, bool status);

mErc20Host_LiquidateExternal

Emitted when a liquidate operation is executed

event mErc20Host_LiquidateExternal(
    address indexed msgSender,
    address indexed srcSender,
    address userToLiquidate,
    address receiver,
    address indexed collateral,
    uint32 srcChainId,
    uint256 amount
);

mErc20Host_MintExternal

Emitted when a mint operation is executed

event mErc20Host_MintExternal(
    address indexed msgSender, address indexed srcSender, address indexed receiver, uint32 chainId, uint256 amount
);

mErc20Host_BorrowExternal

Emitted when a borrow operation is executed

event mErc20Host_BorrowExternal(
    address indexed msgSender, address indexed srcSender, uint32 indexed chainId, uint256 amount
);

mErc20Host_RepayExternal

Emitted when a repay operation is executed

event mErc20Host_RepayExternal(
    address indexed msgSender, address indexed srcSender, address indexed position, uint32 chainId, uint256 amount
);

mErc20Host_WithdrawExternal

Emitted when a withdrawal is executed

event mErc20Host_WithdrawExternal(
    address indexed msgSender, address indexed srcSender, uint32 indexed chainId, uint256 amount
);

mErc20Host_BorrowOnExtensionChain

Emitted when a borrow operation is triggered for an extension chain

event mErc20Host_BorrowOnExtensionChain(address indexed sender, uint32 dstChainId, uint256 amount);

mErc20Host_WithdrawOnExtensionChain

Emitted when a withdraw operation is triggered for an extension chain

event mErc20Host_WithdrawOnExtensionChain(address indexed sender, uint32 dstChainId, uint256 amount);

mErc20Host_GasFeeUpdated

Emitted when gas fees are updated for a dst chain

event mErc20Host_GasFeeUpdated(uint32 indexed dstChainId, uint256 amount);

mErc20Host_MintMigration

event mErc20Host_MintMigration(address indexed receiver, uint256 amount);

mErc20Host_BorrowMigration

event mErc20Host_BorrowMigration(address indexed borrower, uint256 amount);

Errors

mErc20Host_ProofGenerationInputNotValid

Thrown when the chain id is not LINEA

error mErc20Host_ProofGenerationInputNotValid();

mErc20Host_DstChainNotValid

Thrown when the dst chain id is not current chain

error mErc20Host_DstChainNotValid();

mErc20Host_ChainNotValid

Thrown when the chain id is not LINEA

error mErc20Host_ChainNotValid();

mErc20Host_AddressNotValid

Thrown when the address is not valid

error mErc20Host_AddressNotValid();

mErc20Host_AmountTooBig

Thrown when the amount provided is bigger than the available amount`

error mErc20Host_AmountTooBig();

mErc20Host_AmountNotValid

Thrown when the amount specified is invalid (e.g., zero)

error mErc20Host_AmountNotValid();

mErc20Host_JournalNotValid

Thrown when the journal data provided is invalid or corrupted

error mErc20Host_JournalNotValid();

mErc20Host_CallerNotAllowed

Thrown when caller is not allowed

error mErc20Host_CallerNotAllowed();

mErc20Host_NotRebalancer

Thrown when caller is not rebalancer

error mErc20Host_NotRebalancer();

mErc20Host_LengthMismatch

Thrown when length of array is not valid

error mErc20Host_LengthMismatch();

mErc20Host_NotEnoughGasFee

Thrown when not enough gas fee was received

error mErc20Host_NotEnoughGasFee();

mErc20Host_L1InclusionRequired

Thrown when L1 inclusion is required

error mErc20Host_L1InclusionRequired();

ImTokenOperationTypes

Git Source

Enums

OperationType

enum OperationType {
    AmountIn,
    AmountInHere,
    AmountOut,
    AmountOutHere,
    Seize,
    Transfer,
    Mint,
    Borrow,
    Repay,
    Redeem,
    Liquidate,
    Rebalancing
}

ImTokenDelegator

Git Source

Functions

delegate

Non-standard token able to delegate

function delegate(address delegatee) external;

ImTokenMinimal

Git Source

Functions

name

EIP-20 token name for this token

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

symbol

EIP-20 token symbol for this token

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

decimals

EIP-20 token decimals for this token

function decimals() external view returns (uint8);

totalSupply

Returns the value of tokens in existence.

function totalSupply() external view returns (uint256);

totalUnderlying

Returns the amount of underlying tokens

function totalUnderlying() external view returns (uint256);

balanceOf

Returns the value of tokens owned by account.

function balanceOf(address account) external view returns (uint256);

Parameters

isMToken

Returns true

function isMToken() external view returns (bool);

underlying

Returns the underlying address

function underlying() external view returns (address);

ImToken

Git Source

Inherits: ImTokenMinimal

Functions

rolesOperator

Roles manager

function rolesOperator() external view returns (IRoles);

admin

Administrator for this contract

function admin() external view returns (address payable);

pendingAdmin

Pending administrator for this contract

function pendingAdmin() external view returns (address payable);

operator

Contract which oversees inter-mToken operations

function operator() external view returns (address);

interestRateModel

Model which tells what the current interest rate should be

function interestRateModel() external view returns (address);

reserveFactorMantissa

Fraction of interest currently set aside for reserves

function reserveFactorMantissa() external view returns (uint256);

accrualBlockTimestamp

Block timestamp that interest was last accrued at

function accrualBlockTimestamp() external view returns (uint256);

borrowIndex

Accumulator of the total earned interest rate since the opening of the market

function borrowIndex() external view returns (uint256);

totalBorrows

Total amount of outstanding borrows of the underlying in this market

function totalBorrows() external view returns (uint256);

totalReserves

Total amount of reserves of the underlying held in this market

function totalReserves() external view returns (uint256);

sameChainFlowStateDisabled

Returns true/false for same chain flow state disable status

function sameChainFlowStateDisabled() external view returns (bool);

transfer

Transfers amount tokens to the dst address

function transfer(address dst, uint256 amount) external returns (bool);

Parameters

Returns

transferFrom

Transfers amount tokens from the src address to the dst address

function transferFrom(address src, address dst, uint256 amount) external returns (bool);

Parameters

Returns

approve

Approves spender to spend amount tokens on behalf of the caller

function approve(address spender, uint256 amount) external returns (bool);

Parameters

Returns

allowance

Returns the current allowance the spender has from the owner

function allowance(address owner, address spender) external view returns (uint256);

Parameters

Returns

balanceOf

Returns the balance of tokens held by owner

function balanceOf(address owner) external view returns (uint256);

Parameters

Returns

balanceOfUnderlying

Returns the underlying asset balance of the owner

function balanceOfUnderlying(address owner) external returns (uint256);

Parameters

Returns

getAccountSnapshot

Returns the snapshot of account details for the given account

function getAccountSnapshot(address account) external view returns (uint256, uint256, uint256);

Parameters

Returns

borrowRatePerBlock

Returns the current borrow rate per block

function borrowRatePerBlock() external view returns (uint256);

Returns

supplyRatePerBlock

Returns the current supply rate per block

function supplyRatePerBlock() external view returns (uint256);

Returns

totalBorrowsCurrent

Returns the total amount of borrows, accounting for interest

function totalBorrowsCurrent() external returns (uint256);

Returns

borrowBalanceCurrent

Returns the current borrow balance for account, accounting for interest

function borrowBalanceCurrent(address account) external returns (uint256);

Parameters

Returns

borrowBalanceStored

Returns the stored borrow balance for account, without accruing interest

function borrowBalanceStored(address account) external view returns (uint256);

Parameters

Returns

exchangeRateCurrent

Returns the current exchange rate, with interest accrued

function exchangeRateCurrent() external returns (uint256);

Returns

exchangeRateStored

Returns the stored exchange rate, without accruing interest

function exchangeRateStored() external view returns (uint256);

Returns

getCash

Returns the total amount of available cash in the contract

function getCash() external view returns (uint256);

Returns

accrueInterest

Accrues interest on the contract's outstanding loans

function accrueInterest() external;

seize

Transfers collateral tokens (this market) to the liquidator.

Will fail unless called by another mToken during the process of liquidation. Its absolutely critical to use msg.sender as the borrowed mToken and not a parameter.

function seize(address liquidator, address borrower, uint256 seizeTokens) external;

Parameters

reduceReserves

Accrues interest and reduces reserves by transferring to admin

function reduceReserves(uint256 reduceAmount) external;

Parameters

ImTokenGateway

Git Source

Functions

rolesOperator

Roles manager

function rolesOperator() external view returns (IRoles);

underlying

Returns the address of the underlying token

function underlying() external view returns (address);

Returns

isPaused

returns pause state for operation

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

Parameters

accAmountIn

Returns accumulated amount in per user

function accAmountIn(address user) external view returns (uint256);

accAmountOut

Returns accumulated amount out per user

function accAmountOut(address user) external view returns (uint256);

isCallerAllowed

Returns if a caller is allowed for sender

function isCallerAllowed(address sender, address caller) external view returns (bool);

getProofData

Returns the proof data journal

function getProofData(address user, uint32 dstId) external view returns (uint256, uint256);

extractForRebalancing

Extract amount to be used for rebalancing operation

function extractForRebalancing(uint256 amount) external;

Parameters

setPaused

Set pause for a specific operation

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

Parameters

updateAllowedCallerStatus

Set caller status for msg.sender

function updateAllowedCallerStatus(address caller, bool status) external;

Parameters

supplyOnHost

Supply underlying to the contract

function supplyOnHost(uint256 amount, address receiver, bytes4 lineaSelector) external payable;

Parameters

outHere

Extract tokens

function outHere(bytes calldata journalData, bytes calldata seal, uint256[] memory amounts, address receiver)
    external;

Parameters

Events

AllowedCallerUpdated

Emitted when a user updates allowed callers

event AllowedCallerUpdated(address indexed sender, address indexed caller, bool status);

mTokenGateway_Supplied

Emitted when a supply operation is initiated

event mTokenGateway_Supplied(
    address indexed from,
    address indexed receiver,
    uint256 accAmountIn,
    uint256 accAmountOut,
    uint256 amount,
    uint32 srcChainId,
    uint32 dstChainId,
    bytes4 lineaMethodSelector
);

mTokenGateway_Extracted

Emitted when an extract was finalized

event mTokenGateway_Extracted(
    address indexed msgSender,
    address indexed srcSender,
    address indexed receiver,
    uint256 accAmountIn,
    uint256 accAmountOut,
    uint256 amount,
    uint32 srcChainId,
    uint32 dstChainId
);

mTokenGateway_Skipped

Emitted when a proof was skipped

event mTokenGateway_Skipped(
    address indexed msgSender,
    address indexed srcSender,
    address indexed receiver,
    uint256 accAmountIn,
    uint256 accAmountOut,
    uint256 amount,
    uint32 srcChainId,
    uint32 dstChainId
);

mTokenGateway_GasFeeUpdated

Emitted when the gas fee is updated

event mTokenGateway_GasFeeUpdated(uint256 amount);

mTokenGateway_PausedState

event mTokenGateway_PausedState(ImTokenOperationTypes.OperationType indexed _type, bool _status);

ZkVerifierUpdated

event ZkVerifierUpdated(address indexed oldVerifier, address indexed newVerifier);

mTokenGateway_UserWhitelisted

event mTokenGateway_UserWhitelisted(address indexed user, bool status);

mTokenGateway_WhitelistEnabled

event mTokenGateway_WhitelistEnabled();

mTokenGateway_WhitelistDisabled

event mTokenGateway_WhitelistDisabled();

Errors

mTokenGateway_ChainNotValid

Thrown when the chain id is not LINEA

error mTokenGateway_ChainNotValid();

mTokenGateway_AddressNotValid

Thrown when the address is not valid

error mTokenGateway_AddressNotValid();

mTokenGateway_AmountNotValid

Thrown when the amount specified is invalid (e.g., zero)

error mTokenGateway_AmountNotValid();

mTokenGateway_JournalNotValid

Thrown when the journal data provided is invalid

error mTokenGateway_JournalNotValid();

mTokenGateway_AmountTooBig

Thrown when there is insufficient cash to release the specified amount

error mTokenGateway_AmountTooBig();

mTokenGateway_ReleaseCashNotAvailable

Thrown when there is insufficient cash to release the specified amount

error mTokenGateway_ReleaseCashNotAvailable();

mTokenGateway_NonTransferable

Thrown when token is tranferred

error mTokenGateway_NonTransferable();

mTokenGateway_CallerNotAllowed

Thrown when caller is not allowed

error mTokenGateway_CallerNotAllowed();

mTokenGateway_Paused

Thrown when market is paused for operation type

error mTokenGateway_Paused(ImTokenOperationTypes.OperationType _type);

mTokenGateway_NotRebalancer

Thrown when caller is not rebalancer

error mTokenGateway_NotRebalancer();

mTokenGateway_LengthNotValid

Thrown when length is not valid

error mTokenGateway_LengthNotValid();

mTokenGateway_NotEnoughGasFee

Thrown when not enough gas fee was received

error mTokenGateway_NotEnoughGasFee();

mTokenGateway_L1InclusionRequired

Thrown when L1 inclusion is required

error mTokenGateway_L1InclusionRequired();

mTokenGateway_UserNotWhitelisted

Thrown when user is not whitelisted

error mTokenGateway_UserNotWhitelisted();

Contents

• Bytes32AddressLib
• BytesLib
• CREATE3
• IToken
• SafeApprove
• mTokenProofDecoderLib

Bytes32AddressLib

Git Source

Author: Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Bytes32AddressLib.sol)

Library for converting between addresses and bytes32 values.

Functions

fromLast20Bytes

function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address);

fillLast12Bytes

function fillLast12Bytes(address addressValue) internal pure returns (bytes32);

BytesLib

Git Source

Functions

concat

function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory);

concatStorage

function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal;

slice

function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory);

toAddress

function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address);

toUint8

function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8);

toUint16

function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16);

toUint32

function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32);

toUint64

function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64);

toUint96

function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96);

toUint128

function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128);

toUint256

function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256);

toBytes32

function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32);

equal

function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool);

equal_nonAligned

function equal_nonAligned(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool);

equalStorage

function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool);

CREATE3

Git Source

Authors: Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/CREATE3.sol), Modified from 0xSequence (https://github.com/0xSequence/create3/blob/master/contracts/Create3.sol)

Deploy to deterministic addresses without an initcode factor.

State Variables

PROXY_BYTECODE

bytes internal constant PROXY_BYTECODE = hex"67363d3d37363d34f03d5260086018f3";

PROXY_BYTECODE_HASH

bytes32 internal constant PROXY_BYTECODE_HASH = keccak256(PROXY_BYTECODE);

Functions

deploy

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

getDeployed

function getDeployed(bytes32 salt) internal view returns (address);

IToken

Git Source

Functions

approve

function approve(address spender, uint256 amount) external returns (bool);

SafeApprove

Git Source

Functions

safeApprove

function safeApprove(address token, address to, uint256 value) internal;

Errors

SafeApprove_NoContract

error SafeApprove_NoContract();

SafeApprove_Failed

error SafeApprove_Failed();

mTokenProofDecoderLib

Git Source

State Variables

ENTRY_SIZE

uint256 public constant ENTRY_SIZE = 113;

Functions

decodeJournal

function decodeJournal(bytes memory journalData)
    internal
    pure
    returns (
        address sender,
        address market,
        uint256 accAmountIn,
        uint256 accAmountOut,
        uint32 chainId,
        uint32 dstChainId,
        bool L1inclusion
    );

encodeJournal

function encodeJournal(
    address sender,
    address market,
    uint256 accAmountIn,
    uint256 accAmountOut,
    uint32 chainId,
    uint32 dstChainId,
    bool L1inclusion
) internal pure returns (bytes memory);

Errors

mTokenProofDecoderLib_ChainNotFound

error mTokenProofDecoderLib_ChainNotFound();

mTokenProofDecoderLib_InvalidLength

error mTokenProofDecoderLib_InvalidLength();

mTokenProofDecoderLib_InvalidInclusion

error mTokenProofDecoderLib_InvalidInclusion();

Contents

• extension
• host
• BatchSubmitter
• mErc20
• mErc20Immutable
• mErc20Upgradable
• mToken
• mTokenConfiguration
• mTokenStorage

Contents

• mTokenGateway

mTokenGateway

Git Source

Inherits: OwnableUpgradeable, ImTokenGateway, ImTokenOperationTypes

State Variables

rolesOperator

Roles manager

IRoles public rolesOperator;

verifier

IZkVerifier public verifier;

paused

mapping(OperationType => bool) public paused;

underlying

Returns the address of the underlying token

address public underlying;

accAmountIn

mapping(address => uint256) public accAmountIn;

accAmountOut

mapping(address => uint256) public accAmountOut;

allowedCallers

mapping(address => mapping(address => bool)) public allowedCallers;

userWhitelisted

mapping(address => bool) public userWhitelisted;

whitelistEnabled

bool public whitelistEnabled;

LINEA_CHAIN_ID

uint32 private constant LINEA_CHAIN_ID = 59144;

gasFee

gas fee for supplyOnHost

uint256 public gasFee;

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor();

initialize

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

notPaused

modifier notPaused(OperationType _type);

onlyAllowedUser

modifier onlyAllowedUser(address user);

isPaused

returns pause state for operation

function isPaused(OperationType _type) external view returns (bool);

Parameters

isCallerAllowed

Returns if a caller is allowed for sender

function isCallerAllowed(address sender, address caller) external view returns (bool);

getProofData

Returns the proof data journal

function getProofData(address user, uint32) external view returns (uint256, uint256);

setWhitelistedUser

Sets user whitelist status

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

Parameters

enableWhitelist

Enable user whitelist

function enableWhitelist() external onlyOwner;

disableWhitelist

Disable user whitelist

function disableWhitelist() external onlyOwner;

setPaused

Set pause for a specific operation

function setPaused(OperationType _type, bool state) external override;

Parameters

extractForRebalancing

Extract amount to be used for rebalancing operation

function extractForRebalancing(uint256 amount) external notPaused(OperationType.Rebalancing);

Parameters

setUnderlying

function setUnderlying(address _addr) external onlyOwner;

setGasFee

Sets the gas fee

function setGasFee(uint256 amount) external onlyOwner;

Parameters

withdrawGasFees

Withdraw gas received so far

function withdrawGasFees(address payable receiver) external;

Parameters

updateZkVerifier

Updates IZkVerifier address

function updateZkVerifier(address _zkVerifier) external onlyOwner;

Parameters

updateAllowedCallerStatus

Set caller status for msg.sender

function updateAllowedCallerStatus(address caller, bool status) external override;

Parameters

supplyOnHost

Supply underlying to the contract

function supplyOnHost(uint256 amount, address receiver, bytes4 lineaSelector)
    external
    payable
    override
    notPaused(OperationType.AmountIn)
    onlyAllowedUser(msg.sender);

Parameters

outHere

Extract tokens

function outHere(bytes calldata journalData, bytes calldata seal, uint256[] calldata amounts, address receiver)
    external
    notPaused(OperationType.AmountOutHere);

Parameters

_outHere

function _outHere(bytes memory journalData, uint256 amount, address receiver) internal;

_verifyProof

function _verifyProof(bytes calldata journalData, bytes calldata seal) private view;

_checkSender

function _checkSender(address msgSender, address srcSender) private view;

_getSequencerRole

function _getSequencerRole() private view returns (bytes32);

_getBatchProofForwarderRole

function _getBatchProofForwarderRole() private view returns (bytes32);

_getProofForwarderRole

function _getProofForwarderRole() private view returns (bytes32);

_isAllowedFor

function _isAllowedFor(address _sender, bytes32 role) private view returns (bool);

Contents

• mErc20Host

mErc20Host

Git Source

Inherits: mErc20Upgradable, ImErc20Host, ImTokenOperationTypes

State Variables

FLASH_MINT_CALLBACK_SUCCESS

bytes4 private constant FLASH_MINT_CALLBACK_SUCCESS = bytes4(keccak256("onFlashMint(address,uint256,bytes)"));

migrator

address public migrator;

accAmountInPerChain

mapping(uint32 => mapping(address => uint256)) public accAmountInPerChain;

accAmountOutPerChain

mapping(uint32 => mapping(address => uint256)) public accAmountOutPerChain;

allowedCallers

mapping(address => mapping(address => bool)) public allowedCallers;

allowedChains

mapping(uint32 => bool) public allowedChains;

gasFees

mapping(uint32 => uint256) public gasFees;

verifier

IZkVerifier public verifier;

Functions

onlyMigrator

modifier onlyMigrator();

initialize

Initializes the new money market

function initialize(
    address underlying_,
    address operator_,
    address interestRateModel_,
    uint256 initialExchangeRateMantissa_,
    string memory name_,
    string memory symbol_,
    uint8 decimals_,
    address payable admin_,
    address zkVerifier_,
    address roles_
) external initializer;

Parameters

isCallerAllowed

Returns if a caller is allowed for sender

function isCallerAllowed(address sender, address caller) external view returns (bool);

getProofData

Returns the proof data journal

function getProofData(address user, uint32 dstId) external view returns (uint256, uint256);

updateAllowedChain

Updates an allowed chain status

function updateAllowedChain(uint32 _chainId, bool _status) external;

Parameters

extractForRebalancing

Extract amount to be used for rebalancing operation

function extractForRebalancing(uint256 amount) external;

Parameters

setMigrator

Sets the migrator address

function setMigrator(address _migrator) external onlyAdmin;

Parameters

setGasFee

Sets the gas fee

function setGasFee(uint32 dstChainId, uint256 amount) external onlyAdmin;

Parameters

withdrawGasFees

Withdraw gas received so far

function withdrawGasFees(address payable receiver) external;

Parameters

updateZkVerifier

Updates IZkVerifier address

function updateZkVerifier(address _zkVerifier) external onlyAdmin;

Parameters

updateAllowedCallerStatus

Set caller status for msg.sender

function updateAllowedCallerStatus(address caller, bool status) external override;

Parameters

liquidateExternal

Mints tokens after external verification

function liquidateExternal(
    bytes calldata journalData,
    bytes calldata seal,
    address[] calldata userToLiquidate,
    uint256[] calldata liquidateAmount,
    address[] calldata collateral,
    address receiver
) external override;

Parameters

mintExternal

Mints tokens after external verification

function mintExternal(
    bytes calldata journalData,
    bytes calldata seal,
    uint256[] calldata mintAmount,
    uint256[] calldata minAmountsOut,
    address receiver
) external override;

Parameters

repayExternal

Repays tokens after external verification

function repayExternal(
    bytes calldata journalData,
    bytes calldata seal,
    uint256[] calldata repayAmount,
    address receiver
) external override;

Parameters