Mure: Smart Contract Suite

Welcome to Mure, a comprehensive suite of smart contracts designed for easy transactions regarding fundraising, distribution, and payments. Our project is built with security, efficiency, and scalability in mind, leveraging the robust capabilities of the Ethereum blockchain.

About

Mure aims to make safe, scalable and trustless transactions available for anyone, even if they don’t have blockchain experience. Developed using Solidity, our contracts are meticulously designed to ensure secure, gas-efficient, and self-custodial management of funds and payments.

Powered by Foundry

Our development process is empowered by Foundry, a blazing-fast, portable, and modular toolkit for Ethereum application development. Foundry allows us to:

• Test: Conduct comprehensive tests with flexibility and high performance.
• Build: Compile Solidity code swiftly, ensuring rapid development cycles.
• Deploy: Streamline smart contract deployment with precise control over network interactions.

Features

• Fundraising: Collect funds from various sources and get automatic, on-chain bookkeeping for easy dispersement of on-chain assets.
• Distribution: Distribute funds through airdrops or claims, leveraging the data stored from the deposits made by the customer.
• Payments: Leverage the blockchain for the on-chain security and use it as a payments confirmation layer to hook into your off-chain store or service business.

API Documentation

Our APIs are used to interface with your smart contract and help with off-chain needs like KYC, AML, allowlisting, and so on.

For detailed information about our API documentation and how to interact with them, please refer to the API Documentation.

License

Mure is released under the BUSL-1.1. See the LICENSE file for more details.

Contact

For any inquiries or to discuss collaboration, please reach out to hello@mure.app.

Contents

• Chargeable
• Claimable
• Config
• PoolConfig
• DelegateErrorReason
• Delegatable
• DepositArgs
• DepositRecord
• FeeConfig
• DepositPermit
• Depositable
• Distributable
• IERC165
• IERC721Metadata
• IERC20Burnable
• PoolApp
• PoolState
• PoolMetadata
• PoolParameters
• PoolMetrics
• PoolParameter
• PoolErrorReason
• Poolable
• Refundable

Chargeable

Git Source

Author: Mure

Interface for the fees related functionalities for ClaimPlugin

Functions

calculateFee

function calculateFee(address poolContract, string calldata poolName, address depositor)
    external
    view
    returns (uint256);

Claimable

Git Source

Inherits: IERC165

Author: Mure

Interface for claim functionality of pools with support for ERC-165 detection.

Functions

claim

function claim(ClaimRecord calldata claim) external returns (uint256 depositDelta, uint256 claimDelta);

deltas

function deltas(ClaimRecord calldata claimRecord)
    external
    pure
    returns (uint256 depositDelta, uint256 claimDelta, uint256 fee);

Events

Claim

event Claim(address indexed depositor, uint256 indexed amount);

Errors

BalanceMismatch

error BalanceMismatch(uint256 collectedFunds, uint256 reserves);

Structs

ClaimRecord

struct ClaimRecord {
    address claimCurrency;
    address depositor;
    uint256 share;
    uint256 supply;
    uint256 claimReserves;
    uint256 depositReserves;
    uint256 deposit;
    uint256 totalCollected;
    string poolName;
    address custodian;
    uint16 feePercentage;
}

Config

Git Source

Inherits: IERC165

Author: Mure

Interface for MureConfig core with support for ERC-165 detection.

Functions

getAppDelegate

Must not revert, should return address(0) incase delegate does not exist

function getAppDelegate(address poolApp) external returns (address);

setAppDelegate

function setAppDelegate(address poolApp, address delegate) external;

verifyMureSignature

function verifyMureSignature(bytes32 structHash, bytes memory signature) external;

toggleWhitelistedSigner

function toggleWhitelistedSigner(address mureSigner_) external;

PoolConfig

Git Source

struct PoolConfig {
uint256 claimReserves;
uint256 depositReserves;
uint256 supply;
uint16 plugins;
uint16 feePercentage; // 0 to 10000
address claimCurrency;
}

DelegateErrorReason

Git Source

enum DelegateErrorReason {
TRANSFER_FAILURE,
INVALID_PERCENTAGE,
ALREADY_DEPOSITED_FUNDS
}

Delegatable

Git Source

Inherits: IERC165, PoolMetadata

Author: Mure

Interface for Delegate core with support for ERC-165 detection.

Functions

beforeDeposit

function beforeDeposit(string calldata poolName, uint256 amount, address depositor, bytes memory sig) external;

afterDeposit

function afterDeposit(string calldata poolName, uint256 amount, address depositor, bytes memory sig) external;

beforeRefund

function beforeRefund(string calldata poolName, address depositor) external;

afterRefund

function afterRefund(string calldata poolName, address depositor, uint256 amount) external;

withdrawPoolFunds

function withdrawPoolFunds(string calldata poolName) external;

depositPoolFunds

function depositPoolFunds(string calldata poolName, uint256 refundFunds, uint256 claimFunds) external;

deposit

function deposit(string calldata poolName, DepositArgs calldata depositArgs) external;

refund

function refund(string calldata poolName) external;

refund

function refund(string calldata poolName, address depositor, uint256 amount) external;

claim

function claim(string calldata poolName) external;

sendFunds

function sendFunds(address to, uint256 amount, address currency) external;

poolConfig

function poolConfig(string calldata poolName) external view returns (PoolConfig memory);

poolAddress

function poolAddress() external view returns (address);

deposited

function deposited(string calldata poolName, address depositor) external view returns (uint256);

getClaimCurrency

function getClaimCurrency(string calldata poolName) external view returns (address);

Events

PoolFundsDeposit

event PoolFundsDeposit(string poolName, uint256 indexed refundFunds, uint256 indexed claimFunds);

FundTransfer

event FundTransfer(address indexed to, uint256 indexed amount, address indexed currency);

ConfigUpdate

event ConfigUpdate(string poolName);

PoolContractUpdate

event PoolContractUpdate(address indexed poolContract);

Errors

PluginDisabled

error PluginDisabled(uint16 plugin);

PluginEnabled

error PluginEnabled(uint16 plugin);

InvalidAmount

error InvalidAmount();

DelegateError

error DelegateError(DelegateErrorReason reason);

DepositArgs

Git Source

Structure of deposit arguments

struct DepositArgs {
address depositor;
address payer; // @dev Deprecated, to be removed. The caller is now always the payer
uint256 amount;
bytes data;
FeeConfig feeConfig;
bytes depositSig;
bytes permitSig;
}

DepositRecord

Git Source

Structure of a deposit

struct DepositRecord {
uint112 amount;
uint8 nonce;
}

FeeConfig

Git Source

Structure of fee configuration

struct FeeConfig {
uint112 amount;
address recipient;
}

DepositPermit

Git Source

Structure of a deposit permit

Deprecated, to be removed. The caller is now always the payer. With tightened constraints permit is not necessary

struct DepositPermit {
address depositor;
address caller;
uint256 amount;
string poolName;
}

Depositable

Git Source

Author: Mure

Interface for deposit functionality of pools.

Functions

deposit

function deposit(string calldata poolName, DepositArgs calldata depositDetails) external;

deposited

function deposited(string calldata poolName, address depositor) external view returns (uint256);

Events

Deposit

event Deposit(string poolName, uint256 indexed amount, address indexed from, uint8 indexed nonce, bytes data);

Distributable

Git Source

Functions

distribute

function distribute(DistributionRecord calldata distribution, bytes calldata signature) external;

distribute

function distribute(DistributionRecord calldata distribution, address to, bytes calldata signature) external;

moveDistribution

function moveDistribution(address source, string calldata poolName, address from, address to) external;

distribution

function distribution(address source, string calldata poolName, address depositor)
    external
    view
    returns (DistributionHistory memory);

nonce

function nonce(address depositor) external view returns (uint24);

Events

Move

event Move(address indexed source, address indexed from, address indexed to, string poolName);

Distribution

event Distribution(
    address indexed token,
    address indexed source,
    address indexed depositor,
    address repository,
    string poolName,
    uint256 amount
);

Errors

UnsupportedSource

error UnsupportedSource();

UnsupportedToken

error UnsupportedToken();

Undistributed

error Undistributed();

Structs

DistributionRecord

struct DistributionRecord {
    address token;
    address source;
    address repository;
    address depositor;
    string poolName;
    uint256 amount;
    uint256 deadline;
}

DistributionHistory

struct DistributionHistory {
    uint256 distributed;
}

IERC165

Git Source

Interface of the ERC165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[EIP]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.

Functions

supportsInterface

Returns true if this contract implements the interface defined by interfaceId. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.

function supportsInterface(bytes4 interfaceId) external view returns (bool);

IERC721Metadata

Git Source

Functions

name

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

symbol

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

tokenURI

function tokenURI(uint256 tokenId) external view returns (string memory);

IERC20Burnable

Git Source

Inherits: IERC20

Author: Mure

Interface for IERC20Burnable token extension by Openzeppelin.

Functions

burn

Destroys a value amount of tokens from the caller. See ERC20-_burn.

function burn(uint256 value) external;

burnFrom

Destroys a value amount of tokens from account, deducting from the caller’s allowance. See ERC20-_burn and ERC20-allowance. Requirements:

• the caller must have allowance for accounts’s tokens of at least value.

function burnFrom(address account, uint256 value) external;

PoolApp

Git Source

Inherits: IERC165, Poolable, Depositable, Refundable, PoolMetadata

Author: Mure

Interface for MurePool core with support for ERC-165 detection.

Functions

withdrawPoolFunds

function withdrawPoolFunds(string calldata poolName) external;

refundTo

function refundTo(string calldata poolName, address depositor, uint256 amount) external;

nonce

function nonce(string calldata poolName, address depositor) external view returns (uint8);

updatePoolPaused

function updatePoolPaused(string calldata poolName, bool pause) external;

updatePoolRefundable

function updatePoolRefundable(string calldata poolName, bool refundable) external;

depositPoolFunds

function depositPoolFunds(string calldata poolName, address depositor, uint256 amount) external;

Structs

Transaction

struct Transaction {
    address depositor;
    uint112 amount;
    Operation operation;
}

TransactionWithMetadata

struct TransactionWithMetadata {
    address depositor;
    uint112 amount;
    Operation operation;
    bytes data;
}

Enums

Operation

enum Operation {
    Deposit,
    Withdrawal
}

PoolState

Git Source

Structure of a pool

struct PoolState {
uint112 totalCollected;
uint112 poolSize;
uint16 flags;
uint16 depositors;
uint32 endTime; // uint32 => year 2106
address currency;
address custodian;
address signer;
}

PoolMetadata

Git Source

Author: Mure

Interface for pool information like its state and existence

Functions

isPoolActive

function isPoolActive(string calldata poolName) external view returns (bool);

poolExists

function poolExists(string calldata pool) external view returns (bool);

poolState

function poolState(string calldata poolName) external view returns (PoolState memory);

withdrawableAmount

function withdrawableAmount(string calldata poolName) external view returns (uint112);

PoolParameters

Git Source

Structure of parameters of a pool

struct PoolParameters {
uint112 poolSize;
uint32 endTime; // uint32 => year 2106
uint16 flags;
address currency;
address custodian;
address signer;
}

PoolMetrics

Git Source

Structure for pool metrics. Could be updated in future

struct PoolMetrics {
uint112 totalWithdrawn;
}

PoolParameter

Git Source

enum PoolParameter {
POOL_SIZE,
END_TIME, // UINT32 => YEAR 2106
FLAGS,
DEPOSITORS,
CURRENCY,
CUSTODIAN,
SIGNER
}

PoolErrorReason

Git Source

enum PoolErrorReason {
POOL_SIZE_TOO_SMALL,
TRANSFER_FAILURE,
ARITHMETIC_OUT_OF_BOUNDS,
ALREADY_INVESTED_POOL,
INVALID_POOL_TYPE,
POOL_EMPTY
}

Poolable

Git Source

Author: Mure

Interface for pool administration functionality and pool errors.

Functions

createPool

function createPool(string calldata poolName, PoolParameters calldata params, bytes calldata sig) external;

updatePool

function updatePool(string calldata poolName, PoolParameters calldata params) external;

poolMetrics

function poolMetrics(string calldata poolName) external view returns (PoolMetrics memory);

Events

PoolCreation

event PoolCreation(string poolName);

PoolUpdate

event PoolUpdate(string poolName);

Withdrawal

event Withdrawal(string poolName, uint256 indexed amount, address indexed to, uint8 indexed nonce, bytes data);

ConsumeDepositorNonce

event ConsumeDepositorNonce(string poolName, address indexed depositor, uint8 nonce);

FundWithdrawal

event FundWithdrawal(string poolName, uint256 indexed amount, address indexed to, bytes data);

Errors

PoolClosed

error PoolClosed();

PoolOpen

error PoolOpen();

PoolError

error PoolError(PoolErrorReason reason);

IllegalPoolState

error IllegalPoolState(PoolParameter param);

IllegalPoolOperation

error IllegalPoolOperation(PoolErrorReason reason);

PoolInitialized

error PoolInitialized();

PoolFull

error PoolFull();

PoolPaused

error PoolPaused();

PoolNotEmpty

error PoolNotEmpty();

Refundable

Git Source

Author: Mure

Interface for refund fuctionality for pools with support for ERC-165 detection.

Functions

refund

function refund(string calldata poolName) external;

updatePoolRefundable

function updatePoolRefundable(string calldata poolName, bool refundable) external;

Events

Refund

event Refund(string poolName, uint256 indexed amount, address indexed depositor, bytes data);

Errors

DepositNotFound

error DepositNotFound();

Contents

• MureErrors

MureErrors

Git Source

Author: Mure

Library with global errors for Mure

Errors

InvalidAddress

thrown when address is invalid, eg: zero address

error InvalidAddress(address addr);

SignatureExpired

thrown when a signature has expired before verification

error SignatureExpired();

Unauthorized

thrown when any restricted operation is performed by an unauthorized entity

error Unauthorized();

InvalidDelegate

thrown when address is not a valid delegate

error InvalidDelegate();

PoolNotFound

thrown when pool with given parameters is not found

error PoolNotFound();

InvalidFee

thrown when fee is invalid

error InvalidFee();

NoAdmin

thrown when no member has a DEFAULT_ADMIN_ROLE role

error NoAdmin();

Contents

• mayan
• AxlOwnable
• Upgradable
• MockAxelarGasService
• MockAxelarGateway
• ERC20BurnableMock
• ERC20Mock
• ETHReceiverMock
• MockRelayerV2
• MockERC20

Contents

• interfaces
• libraries
• utils
• FastMCTP
• MayanCircle
• MockFeeManager
• MockMessageTransmitter
• MockTokenMessenger
• MockTokenMessengerV2
• MockTokenMinter
• MockWormhole
• SwiftDest

Contents

• IFeeManager
• IMessageTransmitter
• ITokenMinter
• ITokenMessenger
• ITokenMessengerV2
• IWormhole

IFeeManager

Git Source

Functions

feeCollector

function feeCollector() external view returns (address);

depositFee

function depositFee(address relayer, address token, uint256 amount) external;

calcProtocolBps

function calcProtocolBps(uint64 amount, address tokenIn, bytes32 tokenOut, uint16 destChain, uint8 referrerBps)
    external
    view
    returns (uint8);

IMessageTransmitter

Git Source

Functions

receiveMessage

function receiveMessage(bytes memory message, bytes calldata attestation) external returns (bool success);

localDomain

function localDomain() external view returns (uint32);

ITokenMinter

Git Source

Functions

getLocalToken

function getLocalToken(uint32 remoteDomain, bytes32 remoteToken) external view returns (address localToken);

ITokenMessenger

Git Source

Functions

localMessageTransmitter

function localMessageTransmitter() external view returns (IMessageTransmitter);

localMinter

function localMinter() external view returns (ITokenMinter);

depositForBurn

function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken)
    external
    returns (uint64 nonce);

depositForBurnWithCaller

function depositForBurnWithCaller(
    uint256 amount,
    uint32 destinationDomain,
    bytes32 mintRecipient,
    address burnToken,
    bytes32 destinationCaller
) external returns (uint64 nonce);

ITokenMessengerV2

Git Source

Functions

localMessageTransmitter

function localMessageTransmitter() external view returns (IMessageTransmitter);

localMinter

function localMinter() external view returns (ITokenMinter);

depositForBurnWithHook

function depositForBurnWithHook(
    uint256 amount,
    uint32 destinationDomain,
    bytes32 mintRecipient,
    address burnToken,
    bytes32 destinationCaller,
    uint256 maxFee,
    uint32 minFinalityThreshold,
    bytes memory hookData
) external returns (uint64 nonce);

IWormhole

Git Source

Functions

chainId

function chainId() external view returns (uint16);

messageFee

function messageFee() external view returns (uint256);

parseAndVerifyVM

function parseAndVerifyVM(bytes calldata encodedVM)
    external
    view
    returns (VM memory vm, bool valid, string memory reason);

publishMessage

function publishMessage(uint32 nonce, bytes memory payload, uint8 consistencyLevel)
    external
    payable
    returns (uint64 sequence);

Structs

VM

struct VM {
    uint8 version;
    uint32 timestamp;
    uint32 nonce;
    uint16 emitterChainId;
    bytes32 emitterAddress;
    uint64 sequence;
    uint8 consistencyLevel;
    bytes payload;
    bytes32 txHash;
    uint32 guardianSetIndex;
    bytes signatures;
    bytes32 hash;
}

Contents

• BytesLib

BytesLib

Git Source

Functions

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

toUint256

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

toBytes32

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

concat

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

Contents

• InvalidEmitterChain
• InvalidEmitterAddress
• InvalidOrderHash
• Unauthorized
• DeadlineViolation
• InvalidOrderStatus
• InsufficientAmount
• InvalidAmount
• InvalidWormholeFee
• InvalidGasDrop
• InvalidAction
• InvalidEvmAddr
• OrderNotExists
• InvalidAuctionConfig
• EmitterAddressExists
• SequenceAlreadyUsed
• InvalidSrcChain
• InvalidAuctionMode
• Status
• Action
• AuctionMode
• Order
• OrderParams
• ExtraParams
• Key
• UnlockMsg
• RefundMsg
• RescueMsg
• FulfillMsg
• PaymentParams
• PermitParams
• UnlockParams
• SwiftStructs constants

InvalidEmitterChain

Git Source

error InvalidEmitterChain();

InvalidEmitterAddress

Git Source

error InvalidEmitterAddress();

InvalidOrderHash

Git Source

error InvalidOrderHash();

Unauthorized

Git Source

error Unauthorized();

DeadlineViolation

Git Source

error DeadlineViolation();

InvalidOrderStatus

Git Source

error InvalidOrderStatus();

InsufficientAmount

Git Source

error InsufficientAmount();

InvalidAmount

Git Source

error InvalidAmount();

InvalidWormholeFee

Git Source

error InvalidWormholeFee();

InvalidGasDrop

Git Source

error InvalidGasDrop();

InvalidAction

Git Source

error InvalidAction();

InvalidEvmAddr

Git Source

error InvalidEvmAddr();

OrderNotExists

Git Source

error OrderNotExists(bytes32 orderHash);

InvalidAuctionConfig

Git Source

error InvalidAuctionConfig();

EmitterAddressExists

Git Source

error EmitterAddressExists();

SequenceAlreadyUsed

Git Source

error SequenceAlreadyUsed();

InvalidSrcChain

Git Source

error InvalidSrcChain();

InvalidAuctionMode

Git Source

error InvalidAuctionMode();

Status

Git Source

enum Status {
NONE,
CREATED,
FULFILLED,
SETTLED,
CANCELED,
REFUNDED
}

Action

Git Source

enum Action {
NONE,
SWAP,
FULFILL,
UNLOCK,
COMPRESSED_UNLOCK,
REFUND,
RESCUE
}

AuctionMode

Git Source

enum AuctionMode {
NONE,
LIMIT_ORDER,
DUTCH_AUCTION
}

Order

Git Source

struct Order {
Status status;
uint256 fulfilledAmount;
uint256 createdAt;
}

OrderParams

Git Source

struct OrderParams {
uint8 payloadType;
bytes32 trader;
uint16 destChainId;
bytes32 destAddr;
bytes32 tokenOut;
uint64 minAmountOut;
uint64 gasDrop;
uint64 cancelFee;
uint64 refundFee;
uint64 deadline;
bytes32 referrerAddr;
uint8 referrerBps;
uint8 auctionMode;
bytes32 random;
}

ExtraParams

Git Source

struct ExtraParams {
uint16 srcChainId;
bytes32 tokenIn;
uint8 protocolBps;
bytes32 customPayloadHash;
}

Key

Git Source

struct Key {
uint8 payloadType;
bytes32 trader;
uint16 srcChainId;
bytes32 tokenIn;
bytes32 destAddr;
uint16 destChainId;
bytes32 tokenOut;
uint64 minAmountOut;
uint64 gasDrop;
uint64 cancelFee;
uint64 refundFee;
uint64 deadline;
bytes32 referrerAddr;
uint8 referrerBps;
uint8 protocolBps;
uint8 auctionMode;
bytes32 random;
bytes32 customPayloadHash;
}

UnlockMsg

Git Source

struct UnlockMsg {
uint8 action;
bytes32 orderHash;
uint16 srcChainId;
bytes32 tokenIn;
bytes32 referrerAddr;
uint8 referrerBps;
uint8 protocolBps;
bytes32 unlockReceiver;
bytes32 driver;
uint64 fulfillTime;
}

RefundMsg

Git Source

struct RefundMsg {
uint8 action;
bytes32 orderHash;
uint16 srcChainId;
bytes32 tokenIn;
bytes32 trader;
bytes32 canceler;
uint64 cancelFee;
uint64 refundFee;
}

RescueMsg

Git Source

struct RescueMsg {
uint8 action;
bytes32 orderHash;
uint8 orderStatus;
address token;
uint64 amount;
uint16 chainId;
}

FulfillMsg

Git Source

struct FulfillMsg {
uint8 action;
bytes32 orderHash;
uint64 promisedAmount;
bytes32 driver;
uint16 penaltyPeriod;
}

PaymentParams

Git Source

struct PaymentParams {
uint8 payloadType;
bytes32 orderHash;
uint64 promisedAmount;
uint64 minAmountOut;
address destAddr;
address tokenOut;
uint64 gasDrop;
bool batch;
}

PermitParams

Git Source

struct PermitParams {
uint256 value;
uint256 deadline;
uint8 v;
bytes32 r;
bytes32 s;
}

UnlockParams

Git Source

struct UnlockParams {
bytes32 recipient;
bytes32 driver;
bool batch;
}

Constants

Git Source

UNLOCK_MSG_SIZE

uint256 constant UNLOCK_MSG_SIZE = 161

FastMCTP

Git Source

Inherits: ReentrancyGuard

Constants

ETH_DECIMALS

uint8 internal constant ETH_DECIMALS = 18

CCTPV2_SOURCE_DOMAIN_INDEX

uint256 internal constant CCTPV2_SOURCE_DOMAIN_INDEX = 4

CCTPV2_DESTINATION_DOMAIN_INDEX

uint256 internal constant CCTPV2_DESTINATION_DOMAIN_INDEX = 8

CCTPV2_NONCE_INDEX

uint256 internal constant CCTPV2_NONCE_INDEX = 12

CCTPV2_DETINATION_CALLER_INDEX

uint256 internal constant CCTPV2_DETINATION_CALLER_INDEX = 108

CCTPV2_MESSAGE_BODY_INDEX

uint256 internal constant CCTPV2_MESSAGE_BODY_INDEX = 148

CCTPV2_SOURCE_TOKEN_INDEX

uint256 internal constant CCTPV2_SOURCE_TOKEN_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 4

CCTPV2_MINT_RECIPIENT_INDEX

uint256 internal constant CCTPV2_MINT_RECIPIENT_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 36

HOOK_DATA_INDEX

uint256 internal constant HOOK_DATA_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 228

GAS_LIMIT_FEE_MANAGER

uint256 internal constant GAS_LIMIT_FEE_MANAGER = 1000000

State Variables

cctpTokenMessengerV2

ITokenMessengerV2 public cctpTokenMessengerV2

feeManager

address public feeManager

guardian

address public guardian

paused

bool public paused

whitelistedSwapProtocols

mapping(address => bool) public whitelistedSwapProtocols

whitelistedMsgSenders

mapping(address => bool) public whitelistedMsgSenders

Functions

checkRecipient

modifier checkRecipient(bytes memory cctpMsg) ;

whenNotPaused

modifier whenNotPaused() ;

constructor

constructor(address _cctpTokenMessengerV2, address _feeManager) ;

setCctpTokenMessengerV2

function setCctpTokenMessengerV2(address _cctpTokenMessengerV2) external;

setFeeManager

function setFeeManager(address _feeManager) external;

bridge

function bridge(
    address tokenIn,
    uint256 amountIn,
    uint64 redeemFee,
    uint256 circleMaxFee,
    uint64 gasDrop,
    bytes32 destAddr,
    uint32 destDomain,
    bytes32 referrerAddress,
    uint8 referrerBps,
    uint8 payloadType,
    uint32 minFinalityThreshold,
    bytes memory customPayload
) external nonReentrant whenNotPaused;

createOrder

function createOrder(
    address tokenIn,
    uint256 amountIn,
    uint256 circleMaxFee,
    uint32 destDomain,
    uint32 minFinalityThreshold,
    OrderPayload memory orderPayload
) external nonReentrant whenNotPaused;

fulfillOrder

function fulfillOrder(bytes memory cctpMsg, bytes memory cctpSigs, address swapProtocol, bytes memory swapData)
    external
    payable
    nonReentrant
    checkRecipient(cctpMsg);

refund

function refund(bytes memory cctpMsg, bytes memory cctpSigs) external payable nonReentrant checkRecipient(cctpMsg);

setMintRecipient

function setMintRecipient(uint32 destDomain, address tokenIn, bytes32 mintRecipient) public;

setDomainCallers

function setDomainCallers(uint32 domain, bytes32 caller) public;

setWhitelistedSwapProtocols

function setWhitelistedSwapProtocols(address protocol, bool isWhitelisted) public;

setWhitelistedMsgSenders

function setWhitelistedMsgSenders(address sender, bool isWhitelisted) public;

setPause

function setPause(bool _pause) public;

changeGuardian

function changeGuardian(address newGuardian) public;

claimGuardian

function claimGuardian() public;

rescueToken

function rescueToken(address token, uint256 amount, address to) public;

rescueEth

function rescueEth(uint256 amount, address payable to) public;

rescueRedeem

function rescueRedeem(bytes memory cctpMsg, bytes memory cctpSigs) public;

redeem

function redeem(bytes memory cctpMsg, bytes memory cctpSigs) external payable nonReentrant checkRecipient(cctpMsg);

receiveCctp

function receiveCctp(bytes memory cctpMsg, bytes memory cctpSigs) internal returns (address, uint256);

recreateBridgePayload

function recreateBridgePayload(bytes memory cctpMsg) internal pure returns (BridgePayload memory);

safeCalcFastMCTPProtocolBps

function safeCalcFastMCTPProtocolBps(
    uint8 payloadType,
    address localToken,
    uint256 cctpAmount,
    address tokenOut,
    address referrerAddr,
    uint8 referrerBps
) internal returns (uint8);

safeGetFeeCollector

function safeGetFeeCollector() internal view returns (address);

depositRelayerFee

function depositRelayerFee(address relayer, address token, uint256 amount) internal;

deNormalizeAmount

function deNormalizeAmount(uint256 amount, uint8 decimals) internal pure returns (uint256);

payEth

function payEth(address to, uint256 amount, bool revertOnFailure) internal;

truncateAddress

function truncateAddress(bytes32 b) internal pure returns (address);

receive

receive() external payable;

Events

OrderFulfilled

event OrderFulfilled(uint32 sourceDomain, bytes32 sourceNonce, uint256 amount);

OrderRefunded

event OrderRefunded(uint32 sourceDomain, bytes32 sourceNonce, uint256 amount);

Errors

Paused

error Paused();

Unauthorized

error Unauthorized();

CctpReceiveFailed

error CctpReceiveFailed();

InvalidGasDrop

error InvalidGasDrop();

InvalidMintRecipient

error InvalidMintRecipient();

InvalidRedeemFee

error InvalidRedeemFee();

InvalidPayload

error InvalidPayload();

DeadlineViolation

error DeadlineViolation();

InvalidAddress

error InvalidAddress();

InvalidPayloadType

error InvalidPayloadType();

EthTransferFailed

error EthTransferFailed();

InvalidAmountOut

error InvalidAmountOut();

MintRecipientNotSet

error MintRecipientNotSet();

CallerNotSet

error CallerNotSet();

InvalidRefundFee

error InvalidRefundFee();

AlreadySet

error AlreadySet();

UnauthorizedSwapProtocol

error UnauthorizedSwapProtocol();

UnauthorizedMsgSender

error UnauthorizedMsgSender();

Structs

BridgePayload

struct BridgePayload {
    uint8 payloadType;
    bytes32 destAddr;
    uint64 gasDrop;
    uint64 redeemFee;
    bytes32 referrerAddr;
    uint8 referrerBps;
    bytes32 customPayload;
}

OrderPayload

struct OrderPayload {
    uint8 payloadType;
    bytes32 destAddr;
    bytes32 tokenOut;
    uint64 amountOutMin;
    uint64 gasDrop;
    uint64 redeemFee;
    uint64 refundFee;
    uint64 deadline;
    bytes32 referrerAddr;
    uint8 referrerBps;
}

MayanCircle

Git Source

Inherits: ReentrancyGuard

Constants

ETH_DECIMALS

uint8 constant ETH_DECIMALS = 18

CCTP_DOMAIN_INDEX

uint256 constant CCTP_DOMAIN_INDEX = 4

CCTP_NONCE_INDEX

uint256 constant CCTP_NONCE_INDEX = 12

CCTP_TOKEN_INDEX

uint256 constant CCTP_TOKEN_INDEX = 120

CCTP_RECIPIENT_INDEX

uint256 constant CCTP_RECIPIENT_INDEX = 152

CCTP_AMOUNT_INDEX

uint256 constant CCTP_AMOUNT_INDEX = 208

State Variables

wormhole

IWormhole public wormhole

cctpTokenMessenger

ITokenMessenger public cctpTokenMessenger

feeManager

IFeeManager public feeManager

localDomain

uint32 public localDomain

auctionChainId

uint16 public auctionChainId

auctionAddr

bytes32 public auctionAddr

consistencyLevel

uint8 public consistencyLevel

guardian

address public guardian

paused

bool public paused

chainIdToEmitter

mapping(uint16 => bytes32) public chainIdToEmitter

Functions

constructor

constructor(
    address _cctpTokenMessenger,
    address _wormhole,
    address _feeManager,
    uint16 _auctionChainId,
    bytes32 _auctionAddr,
    uint8 _consistencyLevel
) ;

setWormhole

function setWormhole(address _wormhole) external;

setCctpTokenMessenger

function setCctpTokenMessenger(address _cctpTokenMessenger) external;

setFeeManager

function setFeeManager(address _feeManager) external;

bridgeWithFee

function bridgeWithFee(
    address tokenIn,
    uint256 amountIn,
    uint64 redeemFee,
    uint64 gasDrop,
    bytes32 destAddr,
    uint32 destDomain,
    uint8 payloadType,
    bytes memory customPayload
) external payable nonReentrant returns (uint64 sequence);

bridgeWithLockedFee

function bridgeWithLockedFee(
    address tokenIn,
    uint256 amountIn,
    uint64 gasDrop,
    uint256 redeemFee,
    uint32 destDomain,
    bytes32 destAddr
) external nonReentrant returns (uint64 cctpNonce);

createOrder

function createOrder(OrderParams memory params) external payable nonReentrant returns (uint64 sequence);

redeemWithLockedFee

function redeemWithLockedFee(bytes memory cctpMsg, bytes memory cctpSigs, bytes32 unlockerAddr)
    external
    payable
    nonReentrant
    returns (uint64 sequence);

refineFee

function refineFee(uint32 cctpNonce, uint32 cctpDomain, bytes32 destAddr, bytes32 unlockerAddr)
    external
    payable
    nonReentrant
    returns (uint64 sequence);

unlockFee

function unlockFee(bytes memory encodedVm, UnlockFeeMsg memory unlockMsg) external nonReentrant;

unlockFeeRefined

function unlockFeeRefined(
    bytes memory encodedVm1,
    bytes memory encodedVm2,
    UnlockFeeMsg memory unlockMsg,
    UnlockRefinedFeeMsg memory refinedMsg
) external nonReentrant;

fulfillOrder

function fulfillOrder(
    bytes memory cctpMsg,
    bytes memory cctpSigs,
    bytes memory encodedVm,
    FulfillParams memory params,
    address swapProtocol,
    bytes memory swapData
) external payable nonReentrant;

refund

function refund(
    bytes memory encodedVm,
    bytes memory cctpMsg,
    bytes memory cctpSigs,
    OrderParams memory orderParams,
    ExtraParams memory extraParams
) external payable nonReentrant;

setMintRecipient

function setMintRecipient(uint32 destDomain, address tokenIn, bytes32 mintRecipient) public;

setDomainCallers

function setDomainCallers(uint32 domain, bytes32 caller) public;

setEmitter

function setEmitter(uint16 chainId, bytes32 emitter) public;

setDomains

function setDomains(uint16[] memory chainIds, uint32[] memory domains) public;

setConsistencyLevel

function setConsistencyLevel(uint8 _consistencyLevel) public;

setPause

function setPause(bool _pause) public;

rescueToken

function rescueToken(address token, uint256 amount, address to) public;

rescueEth

function rescueEth(uint256 amount, address payable to) public;

changeGuardian

function changeGuardian(address newGuardian) public;

claimGuardian

function claimGuardian() public;

calculatePayloadHashForTest

Debug function to calculate payload hash for testing

This allows tests to compare their hash calculation with the contract’s

function calculatePayloadHashForTest(bytes memory cctpMsg, BridgeWithFeeParams memory bridgeParams)
    public
    pure
    returns (bytes32);

recreateBridgeWithFeeForTest

Debug function to recreate bridge message for testing

function recreateBridgeWithFeeForTest(BridgeWithFeeParams memory bridgeParams, bytes memory cctpMsg)
    public
    pure
    returns (BridgeWithFeeMsg memory);

encodeBridgeWithFeeForTest

Debug function to encode bridge message for testing

function encodeBridgeWithFeeForTest(BridgeWithFeeMsg memory bridgeMsg) public pure returns (bytes memory);

redeemWithFee

function redeemWithFee(
    bytes memory cctpMsg,
    bytes memory cctpSigs,
    bytes memory encodedVm,
    BridgeWithFeeParams memory bridgeParams
) external payable nonReentrant;

receiveCctp

function receiveCctp(bytes memory cctpMsg, bytes memory cctpSigs) internal returns (address, uint256);

validateEmitter

function validateEmitter(bytes32 emitter, uint16 chainId) internal view;

recreateBridgeWithFee

function recreateBridgeWithFee(BridgeWithFeeParams memory bridgeParams, bytes memory cctpMsg)
    internal
    pure
    returns (BridgeWithFeeMsg memory);

encodeBridgeWithFee

function encodeBridgeWithFee(BridgeWithFeeMsg memory bridgeMsg) internal pure returns (bytes memory);

depositRelayerFee

function depositRelayerFee(address relayer, address token, uint256 amount) internal;

deNormalizeAmount

function deNormalizeAmount(uint256 amount, uint8 decimals) internal pure returns (uint256);

payEth

function payEth(address to, uint256 amount, bool revertOnFailure) internal;

truncateAddress

function truncateAddress(bytes32 b) internal pure returns (address);

receive

receive() external payable;

Events

OrderFulfilled

event OrderFulfilled(uint32 sourceDomain, uint64 sourceNonce, uint256 amount);

OrderRefunded

event OrderRefunded(uint32 sourceDomain, uint64 sourceNonce, uint256 amount);

Errors

Paused

error Paused();

Unauthorized

error Unauthorized();

InvalidDomain

error InvalidDomain();

InvalidNonce

error InvalidNonce();

InvalidOrder

error InvalidOrder();

CctpReceiveFailed

error CctpReceiveFailed();

InvalidGasDrop

error InvalidGasDrop();

InvalidAction

error InvalidAction();

InvalidEmitter

error InvalidEmitter();

EmitterAlreadySet

error EmitterAlreadySet();

InvalidDestAddr

error InvalidDestAddr();

InvalidMintRecipient

error InvalidMintRecipient();

InvalidRedeemFee

error InvalidRedeemFee();

InvalidPayload

error InvalidPayload();

CallerNotSet

error CallerNotSet();

MintRecipientNotSet

error MintRecipientNotSet();

InvalidCaller

error InvalidCaller();

DeadlineViolation

error DeadlineViolation();

InvalidAddress

error InvalidAddress();

InvalidReferrerFee

error InvalidReferrerFee();

InvalidProtocolFee

error InvalidProtocolFee();

EthTransferFailed

error EthTransferFailed();

InvalidAmountOut

error InvalidAmountOut();

DomainNotSet

error DomainNotSet();

AlreadySet

error AlreadySet();

Structs

BridgeWithFeeParams

struct BridgeWithFeeParams {
    uint8 payloadType;
    bytes32 destAddr;
    uint64 gasDrop;
    uint64 redeemFee;
    uint64 burnAmount;
    bytes32 burnToken;
    bytes32 customPayload;
}

BridgeWithFeeMsg

struct BridgeWithFeeMsg {
    uint8 action;
    uint8 payloadType;
    uint64 cctpNonce;
    uint32 cctpDomain;
    bytes32 destAddr;
    uint64 gasDrop;
    uint64 redeemFee;
    uint64 burnAmount;
    bytes32 burnToken;
    bytes32 customPayload;
}

OrderParams

struct OrderParams {
    address tokenIn;
    uint256 amountIn;
    uint64 gasDrop;
    bytes32 destAddr;
    uint16 destChain;
    bytes32 tokenOut;
    uint64 minAmountOut;
    uint64 deadline;
    uint64 redeemFee;
    bytes32 referrerAddr;
    uint8 referrerBps;
}

ExtraParams

struct ExtraParams {
    bytes32 trader;
    uint16 sourceChainId;
    uint8 protocolBps;
}

UnlockFeeMsg

struct UnlockFeeMsg {
    uint8 action;
    uint8 payloadType;
    uint64 cctpNonce;
    uint32 cctpDomain;
    bytes32 unlockerAddr;
    uint64 gasDrop;
}

UnlockRefinedFeeMsg

struct UnlockRefinedFeeMsg {
    uint8 action;
    uint8 payloadType;
    uint64 cctpNonce;
    uint32 cctpDomain;
    bytes32 unlockerAddr;
    uint64 gasDrop;
    bytes32 destAddr;
}

FulfillParams

struct FulfillParams {
    bytes32 destAddr;
    uint16 destChainId;
    bytes32 tokenOut;
    uint64 promisedAmount;
    uint64 gasDrop;
    uint64 redeemFee;
    uint64 deadline;
    bytes32 referrerAddr;
    uint8 referrerBps;
    uint8 protocolBps;
    bytes32 driver;
}

Enums

Action

enum Action {
    NONE,
    SWAP,
    FULFILL,
    BRIDGE_WITH_FEE,
    UNLOCK_FEE,
    UNLOCK_FEE_REFINE
}

MockFeeManager

Git Source

Inherits: IFeeManager

Title: MockFeeManager

Mock implementation of IFeeManager for testing Mayan contracts

Handles fee calculations and deposits with configurable values

State Variables

_feeCollector

address public _feeCollector

_defaultProtocolBps

uint8 public _defaultProtocolBps

protocolBps

mapping(address => mapping(bytes32 => mapping(uint16 => uint8))) public protocolBps

Functions

constructor

constructor(address feeCollector_, uint8 defaultProtocolBps_) ;

feeCollector

Get the fee collector address

function feeCollector() external view returns (address);

depositFee

Deposit fee for a relayer

function depositFee(address relayer, address token, uint256 amount) external;

Parameters

calcProtocolBps

Calculate protocol basis points for MayanCircle

function calcProtocolBps(uint64 amount, address tokenIn, bytes32 tokenOut, uint16 destChain, uint8 referrerBps)
    external
    view
    returns (uint8);

Parameters

Returns

calcFastMCTPProtocolBps

Calculate protocol basis points for FastMCTP

function calcFastMCTPProtocolBps(
    uint8 payloadType,
    address localToken,
    uint256 cctpAmount,
    address tokenOut,
    address referrerAddr,
    uint8 referrerBps
) external view returns (uint8);

Parameters

Returns

setProtocolBps

Set protocol basis points for a specific configuration (testing only)

function setProtocolBps(address tokenIn, bytes32 tokenOut, uint16 destChain, uint8 bps) external;

setFeeCollector

Set the fee collector (testing only)

function setFeeCollector(address newFeeCollector) external;

setDefaultProtocolBps

Set the default protocol basis points (testing only)

function setDefaultProtocolBps(uint8 newBps) external;

rescueTokens

Rescue tokens from this contract (testing only)

function rescueTokens(address token, address to, uint256 amount) external;

MockMessageTransmitter

Git Source

Inherits: IMessageTransmitter

Title: MockMessageTransmitter

Mock implementation of IMessageTransmitter for testing CCTP

Receives CCTP messages and mints tokens to the recipient

Constants

CCTP_DOMAIN_INDEX

uint256 constant CCTP_DOMAIN_INDEX = 4

CCTP_NONCE_INDEX

uint256 constant CCTP_NONCE_INDEX = 12

CCTP_TOKEN_INDEX

uint256 constant CCTP_TOKEN_INDEX = 120

CCTP_RECIPIENT_INDEX

uint256 constant CCTP_RECIPIENT_INDEX = 152

CCTP_AMOUNT_INDEX

uint256 constant CCTP_AMOUNT_INDEX = 208

CCTPV2_MESSAGE_BODY_INDEX

uint256 constant CCTPV2_MESSAGE_BODY_INDEX = 148

CCTPV2_SOURCE_TOKEN_INDEX

uint256 constant CCTPV2_SOURCE_TOKEN_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 4

CCTPV2_MINT_RECIPIENT_INDEX

uint256 constant CCTPV2_MINT_RECIPIENT_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 36

CCTPV2_AMOUNT_INDEX

uint256 constant CCTPV2_AMOUNT_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 68

HOOK_DATA_INDEX

uint256 constant HOOK_DATA_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 228

State Variables

_localDomain

uint32 public _localDomain

tokenMinter

address public tokenMinter

Functions

constructor

constructor(uint32 localDomain_, address tokenMinter_) ;

receiveMessage

Receive and process a CCTP message

function receiveMessage(bytes memory message, bytes calldata attestation) external returns (bool success);

Parameters

Returns

localDomain

Get the local domain

function localDomain() external view returns (uint32);

setLocalDomain

Set the local domain (testing only)

function setLocalDomain(uint32 newDomain) external;

setTokenMinter

Set the token minter address (testing only)

function setTokenMinter(address newTokenMinter) external;

mintTokens

Direct mint function for testing

function mintTokens(address token, address recipient, uint256 amount) external;

MockTokenMessenger

Git Source

Inherits: ITokenMessenger

Title: MockTokenMessenger

Mock implementation of ITokenMessenger for testing MayanCircle

Returns references to MockMessageTransmitter and MockTokenMinter

State Variables

_localMessageTransmitter

IMessageTransmitter public _localMessageTransmitter

_localMinter

ITokenMinter public _localMinter

Functions

constructor

constructor(address messageTransmitter, address tokenMinter) ;

localMessageTransmitter

Get the local message transmitter

function localMessageTransmitter() external view returns (IMessageTransmitter);

localMinter

Get the local token minter

function localMinter() external view returns (ITokenMinter);

depositForBurn

Deposit tokens for burn (stub)

function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken)
    external
    returns (uint64 nonce);

depositForBurnWithCaller

Deposit tokens for burn with caller (stub)

function depositForBurnWithCaller(
    uint256 amount,
    uint32 destinationDomain,
    bytes32 mintRecipient,
    address burnToken,
    bytes32 destinationCaller
) external returns (uint64 nonce);

setLocalMessageTransmitter

Set the message transmitter (testing only)

function setLocalMessageTransmitter(address newTransmitter) external;

setLocalMinter

Set the token minter (testing only)

function setLocalMinter(address newMinter) external;

MockTokenMessengerV2

Git Source

Inherits: ITokenMessengerV2

Title: MockTokenMessengerV2

Mock implementation of ITokenMessengerV2 for testing FastMCTP

Returns references to MockMessageTransmitter and MockTokenMinter

State Variables

_localMessageTransmitter

IMessageTransmitter public _localMessageTransmitter

_localMinter

ITokenMinter public _localMinter

Functions

constructor

constructor(address messageTransmitter, address tokenMinter) ;

localMessageTransmitter

Get the local message transmitter

function localMessageTransmitter() external view returns (IMessageTransmitter);

localMinter

Get the local token minter

function localMinter() external view returns (ITokenMinter);

depositForBurnWithHook

Deposit tokens for burn with hook (stub)

function depositForBurnWithHook(
    uint256 amount,
    uint32 destinationDomain,
    bytes32 mintRecipient,
    address burnToken,
    bytes32 destinationCaller,
    uint256 maxFee,
    uint32 minFinalityThreshold,
    bytes memory hookData
) external returns (uint64 nonce);

setLocalMessageTransmitter

Set the message transmitter (testing only)

function setLocalMessageTransmitter(address newTransmitter) external;

setLocalMinter

Set the token minter (testing only)

function setLocalMinter(address newMinter) external;

MockTokenMinter

Git Source

Inherits: ITokenMinter

Title: MockTokenMinter

Mock implementation of ITokenMinter for testing

Manages mappings between remote and local tokens

State Variables

tokenMappings

mapping(uint32 => mapping(bytes32 => address)) public tokenMappings

Functions

getLocalToken

Get the local token address for a remote token

function getLocalToken(uint32 remoteDomain, bytes32 remoteToken) external view returns (address localToken);

Parameters

Returns

setLocalToken

Set the local token for a remote token (testing only)

function setLocalToken(uint32 remoteDomain, bytes32 remoteToken, address localToken) external;

Parameters

MockWormhole

Git Source

Inherits: IWormhole

Title: MockWormhole

Mock implementation of IWormhole for testing Mayan contracts

Always returns valid=true for parseAndVerifyVM to pass Wormhole validation

State Variables

_chainId

uint16 public _chainId

_messageFee

uint256 public _messageFee

encodedVMToVM

mapping(bytes => VM) public encodedVMToVM

vmValidity

mapping(bytes => bool) public vmValidity

vmReason

mapping(bytes => string) public vmReason

Functions

constructor

constructor(uint16 chainId_, uint256 messageFee_) ;

parseAndVerifyVM

Parse and verify a Wormhole VM - always returns valid for testing

function parseAndVerifyVM(bytes calldata encodedVM)
    external
    view
    returns (VM memory vm, bool valid, string memory reason);

Parameters

Returns

publishMessage

Publish a message (stub implementation)

function publishMessage(uint32 nonce, bytes memory payload, uint8 consistencyLevel)
    external
    payable
    returns (uint64 sequence);

chainId

Get the chain ID

function chainId() external view returns (uint16);

messageFee

Get the message fee

function messageFee() external view returns (uint256);

setChainId

Set the chain ID (for testing)

function setChainId(uint16 newChainId) external;

setMessageFee

Set the message fee (for testing)

function setMessageFee(uint256 newMessageFee) external;

setVMForEncoded

Configure a specific VM result for encoded bytes

function setVMForEncoded(bytes calldata encodedVM, VM calldata vmData, bool valid, string calldata reason)
    external;

decodeVM

Decode a VM from encoded bytes

Simple decoding - assumes abi.encoded VM structure

function decodeVM(bytes calldata encodedVM) internal view returns (VM memory);

SwiftDest

Git Source

Inherits: ReentrancyGuard

State Variables

wormhole

IWormhole public wormhole

guardian

address public guardian

orders

mapping(bytes32 => Order) public orders

pendingAmounts

mapping(bytes32 => uint256) public pendingAmounts

Functions

constructor

constructor(address _wormhole) ;

setWormhole

function setWormhole(address _wormhole) external;

fulfillOrder

function fulfillOrder(
    uint256 fulfillAmount,
    bytes memory encodedVm,
    OrderParams memory params,
    ExtraParams memory extraParams,
    UnlockParams calldata unlockParams,
    PermitParams calldata permit
) public payable nonReentrant returns (bytes memory);

fulfillSimple

function fulfillSimple(
    uint256 fulfillAmount,
    bytes32 orderHash,
    OrderParams memory params,
    ExtraParams memory extraParams,
    UnlockParams memory unlockParams,
    PermitParams calldata permit
) public payable nonReentrant;

cancelOrder

function cancelOrder(bytes32 orderHash, OrderParams memory params, ExtraParams memory extraParams, bytes32 canceler)
    public
    payable
    nonReentrant
    returns (uint64 sequence);

postBatch

function postBatch(bytes32[] memory orderHashes) public payable returns (uint64 sequence);

rescue

function rescue(bytes memory encodedVm) public;

setPause

function setPause(bool _pause) public;

setAuctionConfig

function setAuctionConfig(address _auctionVerifier, uint16 _auctionChainId, bytes32 _auctionAddr) public;

setConsistencyLevel

function setConsistencyLevel(uint8 _consistencyLevel) public;

setEmitters

function setEmitters(uint16[] memory chainIds, bytes32[] memory addresses) public;

changeGuardian

function changeGuardian(address newGuardian) public;

claimGuardian

function claimGuardian() public;

getOrders

function getOrders(bytes32[] memory orderHashes) public view returns (Order[] memory);

settleWithPayload

function settleWithPayload(OrderParams memory params, ExtraParams memory extraParams)
    public
    nonReentrant
    returns (uint256 netAmount);

buildKey

function buildKey(OrderParams memory params, ExtraParams memory extraParams)
    internal
    pure
    returns (Key memory key);

encodeKey

function encodeKey(Key memory key) internal pure returns (bytes memory encoded);

truncateAddress

function truncateAddress(bytes32 b) internal pure returns (address);

payEth

function payEth(address to, uint256 amount, bool revertOnFailure) internal;

receive

receive() external payable;

Events

OrderSettled

event OrderSettled(bytes32 key, uint256 netAmount);

AxlOwnable

Git Source

Inherits: IOwnable

Title: AxlOwnable

A contract module which provides a basic access control mechanism, where there is an account (an owner) that can be granted exclusive access to specific functions. The owner account is set through ownership transfer. This module makes it possible to transfer the ownership of the contract to a new account in one step, as well as to an interim pending owner. In the second flow the ownership does not change until the pending owner accepts the ownership transfer.

Constants

_OWNER_SLOT

bytes32 internal constant _OWNER_SLOT = 0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0

_OWNERSHIP_TRANSFER_SLOT

bytes32 internal constant _OWNERSHIP_TRANSFER_SLOT =
    0x9855384122b55936fbfb8ca5120e63c6537a1ac40caf6ae33502b3c5da8c87d1

Functions

constructor

Initializes the contract by transferring ownership to the owner parameter.

constructor(address _owner) ;

Parameters

onlyOwner

Modifier that throws an error if called by any account other than the owner.

modifier onlyOwner() ;

owner

Returns the current owner of the contract.

function owner() public view returns (address owner_);

Returns

pendingOwner

Returns the pending owner of the contract.

function pendingOwner() public view returns (address owner_);

Returns

transferOwnership

Transfers ownership of the contract to a new account newOwner.

Can only be called by the current owner.

function transferOwnership(address newOwner) external virtual onlyOwner;

Parameters

proposeOwnership

Propose to transfer ownership of the contract to a new account newOwner.

Can only be called by the current owner. The ownership does not change until the new owner accepts the ownership transfer.

function proposeOwnership(address newOwner) external virtual onlyOwner;

Parameters

acceptOwnership

Accepts ownership of the contract.

Can only be called by the pending owner

function acceptOwnership() external virtual;

_transferOwnership

Internal function to transfer ownership of the contract to a new account newOwner.

Called in the constructor to set the initial owner.

function _transferOwnership(address newOwner) internal virtual;

Parameters

Upgradable

Git Source

Inherits: AxlOwnable, Implementation, IUpgradable

Title: Upgradable Contract

This contract provides an interface for upgradable smart contracts and includes the functionality to perform upgrades.

Constants

_IMPLEMENTATION_SLOT

bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc

Functions

constructor

Constructor sets the implementation address to the address of the contract itself

This is used in the onlyProxy modifier to prevent certain functions from being called directly on the implementation contract itself.

The owner is initially set as address(1) because the actual owner is set within the proxy. It is not set as the zero address because Ownable is designed to throw an error for ownership transfers to the zero address.

constructor() AxlOwnable(address(1));

implementation

Returns the address of the current implementation

function implementation() public view returns (address implementation_);

Returns

upgrade

Upgrades the contract to a new implementation

This function is only callable by the owner.

function upgrade(address newImplementation, bytes32 newImplementationCodeHash, bytes calldata params)
    external
    override
    onlyOwner;

Parameters

setup

Sets up the contract with initial data

This function is only callable by the proxy contract.

function setup(bytes calldata data) external override (IImplementation, Implementation) onlyProxy;

Parameters

_setup

Internal function to set up the contract with initial data

This function should be implemented in derived contracts.

function _setup(bytes calldata data) internal virtual;

Parameters

MockAxelarGasService

Git Source

Inherits: InterchainGasEstimation, Upgradable, IAxelarGasService

Title: AxelarGasService

This contract manages gas payments and refunds for cross-chain communication on the Axelar network.

The owner address of this contract should be the microservice that pays for gas.

Users pay gas for cross-chain calls, and the gasCollector can collect accumulated fees and/or refund users if needed.

Constants

gasCollector

address public immutable gasCollector

Functions

constructor

Constructs the AxelarGasService contract.

constructor(address gasCollector_) ;

Parameters

_setup

function _setup(bytes calldata data) internal override;

onlyCollector

Modifier that ensures the caller is the designated gas collector.

modifier onlyCollector() ;

payGas

Pay for gas for any type of contract execution on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

If estimateOnChain is true, the function will estimate the gas cost and revert if the payment is insufficient.

function payGas(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    uint256 executionGasLimit,
    bool estimateOnChain,
    address refundAddress,
    bytes calldata params
) external payable override;

Parameters

payGasForContractCall

Pay for gas using ERC20 tokens for a contract call on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payGasForContractCall(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    address gasToken,
    uint256 gasFeeAmount,
    address refundAddress
) external override;

Parameters

payGasForContractCallWithToken

Pay for gas using ERC20 tokens for a contract call with tokens on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payGasForContractCallWithToken(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    string memory symbol,
    uint256 amount,
    address gasToken,
    uint256 gasFeeAmount,
    address refundAddress
) external override;

Parameters

payNativeGasForContractCall

Pay for gas using native currency for a contract call on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payNativeGasForContractCall(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    address refundAddress
) external payable override;

Parameters

payNativeGasForContractCallWithToken

Pay for gas using native currency for a contract call with tokens on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payNativeGasForContractCallWithToken(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    string calldata symbol,
    uint256 amount,
    address refundAddress
) external payable override;

Parameters

payGasForExpressCall

Pay for gas using ERC20 tokens for an express contract call on a destination chain.

This function is called on the source chain before calling the gateway to express execute a remote contract.

function payGasForExpressCall(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    address gasToken,
    uint256 gasFeeAmount,
    address refundAddress
) external override;

Parameters

payGasForExpressCallWithToken

Pay for gas using ERC20 tokens for an express contract call with tokens on a destination chain.

This function is called on the source chain before calling the gateway to express execute a remote contract.

function payGasForExpressCallWithToken(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    string memory symbol,
    uint256 amount,
    address gasToken,
    uint256 gasFeeAmount,
    address refundAddress
) external override;

Parameters

payNativeGasForExpressCall

Pay for gas using native currency for an express contract call on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payNativeGasForExpressCall(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    address refundAddress
) external payable override;

Parameters

payNativeGasForExpressCallWithToken

Pay for gas using native currency for an express contract call with tokens on a destination chain.

This function is called on the source chain before calling the gateway to execute a remote contract.

function payNativeGasForExpressCallWithToken(
    address sender,
    string calldata destinationChain,
    string calldata destinationAddress,
    bytes calldata payload,
    string calldata symbol,
    uint256 amount,
    address refundAddress
) external payable override;

Parameters

addGas

Add additional gas payment using ERC20 tokens after initiating a cross-chain call.

This function can be called on the source chain after calling the gateway to execute a remote contract.

function addGas(bytes32 txHash, uint256 logIndex, address gasToken, uint256 gasFeeAmount, address refundAddress)
    external
    override;

Parameters

addNativeGas

Add additional gas payment using native currency after initiating a cross-chain call.

This function can be called on the source chain after calling the gateway to execute a remote contract.

function addNativeGas(bytes32 txHash, uint256 logIndex, address refundAddress) external payable override;

Parameters

addExpressGas

Add additional gas payment using ERC20 tokens after initiating an express cross-chain call.

This function can be called on the source chain after calling the gateway to express execute a remote contract.

function addExpressGas(
    bytes32 txHash,
    uint256 logIndex,
    address gasToken,
    uint256 gasFeeAmount,
    address refundAddress
) external override;

Parameters

addNativeExpressGas

Add additional gas payment using native currency after initiating an express cross-chain call.

This function can be called on the source chain after calling the gateway to express execute a remote contract.

function addNativeExpressGas(bytes32 txHash, uint256 logIndex, address refundAddress) external payable override;

Parameters

updateGasInfo

Updates the gas price for a specific chain.

This function is called by the gas oracle to update the gas prices for a specific chains.

function updateGasInfo(string[] calldata chains, GasInfo[] calldata gasUpdates) external onlyCollector;

Parameters

collectFees

Allows the gasCollector to collect accumulated fees from the contract.

Use address(0) as the token address for native currency.

function collectFees(address payable receiver, address[] calldata tokens, uint256[] calldata amounts)
    external
    onlyCollector;

Parameters

refund

Deprecated refund function, kept for backward compatibility.

function refund(address payable receiver, address token, uint256 amount) external onlyCollector;

refund

Refunds gas payment to the receiver in relation to a specific cross-chain transaction.

Only callable by the gasCollector.

Use address(0) as the token address to refund native currency.

function refund(bytes32 txHash, uint256 logIndex, address payable receiver, address token, uint256 amount)
    external
    onlyCollector;

Parameters

_refund

Internal function to implement gas refund logic.

function _refund(bytes32 txHash, uint256 logIndex, address payable receiver, address token, uint256 amount)
    private;

contractId

Returns a unique identifier for the contract.

function contractId() external pure returns (bytes32);

Returns

MockAxelarGateway

Git Source

Inherits: IAxelarGatewayWithToken

Title: AxelarGateway Contract

This contract serves as the gateway for cross-chain contract calls, and token transfers within the Axelar network. It includes functions for sending tokens, calling contracts, and validating contract calls. The contract is managed via the decentralized governance mechanism on the Axelar network.

EternalStorage is used to simplify storage for upgradability, and InterchainGovernance module is used for governance.

State Variables

tokenMapping

mapping(string => address) tokenMapping

Functions

constructor

constructor() ;

sendToken

Sends tokens to another chain.

Initiates a cross-chain token transfer through the gateway to the specified destination chain and recipient.

function sendToken(
    string calldata destinationChain,
    string calldata destinationAddress,
    string calldata symbol,
    uint256 amount
) external;

Parameters

callContractWithToken

Makes a contract call on another chain with an associated token transfer.

Initiates a cross-chain contract call through the gateway that includes a token transfer to the specified contract on the destination chain.

function callContractWithToken(
    string calldata destinationChain,
    string calldata contractAddress,
    bytes calldata payload,
    string calldata symbol,
    uint256 amount
) external;

Parameters

isContractCallAndMintApproved

Checks if a contract call with token minting is approved.

Determines whether a given contract call, identified by the commandId and payloadHash, involving token minting is approved.

function isContractCallAndMintApproved(
    bytes32 commandId,
    string calldata sourceChain,
    string calldata sourceAddress,
    address contractAddress,
    bytes32 payloadHash,
    string calldata symbol,
    uint256 amount
) external view returns (bool);

Parameters

Returns

validateContractCallAndMint

Validates and approves a contract call with token minting.

Validates the given contract call information and marks it as approved if valid. It also involves the minting of tokens.

function validateContractCallAndMint(
    bytes32 commandId,
    string calldata sourceChain,
    string calldata sourceAddress,
    bytes32 payloadHash,
    string calldata symbol,
    uint256 amount
) external returns (bool);

Parameters

Returns

tokenAddresses

Retrieves the address of a token given its symbol.

Gets the contract address of the token registered with the given symbol.

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

Parameters

Returns

setTokenAddress

Sets the address of a token given its symbol.

Sets the contract address of the token registered with the given symbol.

function setTokenAddress(string memory symbol, address tokenAddress) external;

Parameters

callContract

Sends a contract call to another chain.

Initiates a cross-chain contract call through the gateway to the specified destination chain and contract.

function callContract(string calldata destinationChain, string calldata contractAddress, bytes calldata payload)
    external;

Parameters

isContractCallApproved

Checks if a contract call is approved.

Determines whether a given contract call, identified by the commandId and payloadHash, is approved.

function isContractCallApproved(
    bytes32 commandId,
    string calldata sourceChain,
    string calldata sourceAddress,
    address contractAddress,
    bytes32 payloadHash
) external view returns (bool);

Parameters

Returns

validateContractCall

Validates and approves a contract call.

Validates the given contract call information and marks it as approved if valid.

function validateContractCall(
    bytes32 commandId,
    string calldata sourceChain,
    string calldata sourceAddress,
    bytes32 payloadHash
) external returns (bool);

Parameters

Returns

isCommandExecuted

Checks if a command has been executed.

Determines whether a command, identified by the commandId, has been executed.

function isCommandExecuted(bytes32 commandId) external view returns (bool);

Parameters

Returns

ERC20BurnableMock

Git Source

Inherits: ERC20Burnable

Functions

constructor

constructor(string memory name, string memory symbol) ERC20(name, symbol);

mint

function mint(address to, uint256 amount) public;

ERC20Mock

Git Source

Inherits: ERC20

Functions

constructor

constructor() ERC20("ERC20Mock", "E20M");

mint

function mint(address account, uint256 amount) external;

burn

function burn(address account, uint256 amount) external;

ETHReceiverMock

Git Source

Title: ETHReceiverMock

Simple mock contract that can receive ETH transfers

Used for testing excess ETH refund scenarios

Functions

receive

Fallback function to receive ETH

receive() external payable;

Events

ETHReceived

Emitted when ETH is received

event ETHReceived(address indexed sender, uint256 amount);

MockRelayerV2

Git Source

Inherits: BaseAdapter

Title: MockRelayerV2

Lightweight mock relayer for testing atomic token transfers and fulfillments

Simulates real-world relayer behavior by atomically transferring funds to receiver and calling fulfill(). Used in MetaIntentV2 tests to replace non-atomic test patterns. Demonstrates proper BaseAdapter extension pattern.

Functions

constructor

constructor(address payable _receiver) BaseAdapter(_receiver);

Parameters

relayAndFulfill

Atomically transfer funds to receiver and call fulfill

The relayer must already hold the tokens being transferred. Uses BaseAdapter._fulfillToReceiver() for the actual transfer and fulfill call.

function relayAndFulfill(RelayedOrderOutput calldata output) public payable returns (bytes32 payloadHash);

Parameters

Returns

relayAndFulfillERC20

Convenience function for tests: fund relayer with ERC20, then relay and fulfill

Pulls ERC20 from caller, transfers to receiver, and fulfills

function relayAndFulfillERC20(RelayedOrderOutput calldata output) external returns (bytes32 payloadHash);

Parameters

relayAndFulfillNative

Convenience function for tests: fund relayer with native token, then relay and fulfill

Must be called with sufficient msg.value

function relayAndFulfillNative(RelayedOrderOutput calldata output) external payable returns (bytes32 payloadHash);

Parameters

_decodeMessage

Decode a message into RelayedOrderOutput (mock implementation)

For the mock relayer, this simply returns the passed output directly. Real protocol adapters would decode their specific message format here.

function _decodeMessage(
    bytes calldata /*message*/
)
    internal
    pure
    override
    returns (RelayedOrderOutput memory output);

Returns

Events

RelayAndFulfillCompleted

Emitted when a relay and fulfillment is completed

event RelayAndFulfillCompleted(bytes32 indexed orderId, bytes32 indexed outputHash, address token, uint256 amount);

Errors

InsufficientNativeToken

Revert when insufficient native token provided

error InsufficientNativeToken(uint256 provided, uint256 required);

MockERC20

Git Source

Inherits: ERC20

Functions

constructor

constructor(string memory name, string memory symbol) ERC20(name, symbol);

mint

function mint(address to, uint256 amount) public;

Contents

• ClaimPlugin

ClaimPlugin

Git Source

Inherits: UUPSUpgradeable, OwnableUpgradeable, ERC165Upgradeable, Claimable

Author: Mure Implements UUPSUpgradeable for upgradeability, OwnableUpgradeable for access control, ERC165Upgradeable for interface support, and Claimable interface for compatibility checks. Facilitates the calculation and execution of reward claims, allowing depositors to receive their entitled rewards along with their shares from the total collected pool funds.

Contract managing reward distribution to users of an application.

Functions

initialize

function initialize(address owner) external initializer;

claim

Sends reward funds from the delegate to depositor.

function claim(ClaimRecord calldata claimRecord) external returns (uint256 depositDelta, uint256 claimDelta);

Parameters

deltas

Returns the refund amount, claim amount and fee.

function deltas(ClaimRecord calldata claimRecord)
    public
    pure
    returns (uint256 depositDelta, uint256 claimDelta, uint256 fee);

Parameters

Returns

_calculateShare

Calculates the user share amount.

function _calculateShare(uint256 share, uint256 supply, uint256 reserve) private pure returns (uint256);

Parameters

calculateFee

Calculates the fee to be charged.

function calculateFee(uint256 amount, uint256 feePercentage) private pure returns (uint256);

Parameters

supportsInterface

See IERC165-supportsInterface.

function supportsInterface(bytes4 interfaceId)
    public
    view
    virtual
    override (ERC165Upgradeable, IERC165)
    returns (bool);

_authorizeUpgrade

required by the OZ UUPS module

function _authorizeUpgrade(address) internal override onlyOwner;

Contents

• Constants
• Role
• AppMember
• Types constants

Constants

Git Source

POOL_OPERATOR_ROLE

Role allows user to create and update pools along with pool administration

bytes32 constant POOL_OPERATOR_ROLE = keccak256("POOL_OPERATOR")

DEFAULT_ADMIN_ROLE

Default RBAC admin role

bytes32 constant DEFAULT_ADMIN_ROLE = 0x00

Role

Git Source

Enum for pool member roles

enum Role {
DEFAULT_ADMIN,
POOL_OPERATOR
}

AppMember

Git Source

Struct for a pool member

struct AppMember {
address member;
Role role;
}

Constants

Git Source

APP_MEMBER_HASH

Struct hash for validating app deployments keccak256("AppMember(address member,uint8 role)")

bytes32 constant APP_MEMBER_HASH = 0xe3128a5e7b51cb6b5d75b976cb4b51c8420a8c2a5c60709fd3af893c19fc754a

FEE_CONFIG_HASH

Struct hash for validating deposit fee config keccak256("FeeConfig(uint112 amount,address recipient)")

bytes32 constant FEE_CONFIG_HASH = 0xfec57672da62b01f006c6c3af74423cc502012ed8246681ae395eb5dbaa8e825

Contents

• interfaces
• libraries
• types
• utils
• AcrossAdapter
• BaseAdapter
• MayanAdapter
• MetaIntentReceiver
• MetaIntentTransmitter

Contents

• Adapter
• Receiver
• Transmitter

Adapter

Git Source

Title: Adapter

Interface for adapters that connect underlying protocols to the MetaIntentReceiver

Defines the contract that all adapters must implement to ensure type consistency

Functions

receiver

Returns the MetaIntentReceiver address this adapter forwards to

function receiver() external view returns (address receiverAddr);

Returns

Receiver

Git Source

Title: Receiver

Interface for the MetaIntentReceiver contract

Defines the external API for fulfilling order outputs on destination chain

Functions

fulfill

Fulfill an order output by transferring tokens to the recipient

function fulfill(RelayedOrderOutput calldata output) external returns (bytes32 payloadHash);

Parameters

Returns

Transmitter

Git Source

Title: Transmitter

Interface for the MetaIntentTransmitter contract

Defines the external API for executing meta-intent orders

Functions

execute

Execute a meta-intent order by pulling inputs and executing protocol calls

function execute(Order calldata order) external payable returns (bytes32 orderId);

Parameters

Returns

Contents

• ErrorLib
• LibAddress
• LibToken

ErrorLib

Git Source

Author: Mure

Library with errors for Mure v2 contracts

Errors

NotAuthorizedProtocol

error NotAuthorizedProtocol();

OrderExpired

error OrderExpired();

NoInputsProvided

error NoInputsProvided();

NoCallsProvided

error NoCallsProvided();

ZeroInputAmount

error ZeroInputAmount();

OrderIdMismatch

error OrderIdMismatch();

NonceAlreadyUsed

error NonceAlreadyUsed();

OrderAlreadyExecuted

error OrderAlreadyExecuted();

OutputAlreadyFulfilled

error OutputAlreadyFulfilled();

CallFailed

error CallFailed(uint256 callIndex, bytes returnData);

InsufficientNativeToken

Revert when insufficient native token provided

error InsufficientNativeToken(uint256 provided, uint256 required);

NativeAmountMismatch

error NativeAmountMismatch();

TransferFailed

error TransferFailed();

InvalidCallTarget

error InvalidCallTarget();

IllegalAmountTransferred

error IllegalAmountTransferred();

InsufficientAllowance

error InsufficientAllowance();

InsufficientTokenBalance

error InsufficientTokenBalance(address token, uint256 expected, uint256 actual);

NativeBalanceNotZero

error NativeBalanceNotZero();

TokenBalanceNotZero

error TokenBalanceNotZero(address token);

InvalidCallSignature

error InvalidCallSignature();

LibAddress

Git Source

Title: LibAddress

Library for address-related utility functions

Provides functions for converting addresses to cross-chain identifiers

Functions

toIdentifier

Converts an Ethereum address to a bytes32 identifier that can be used across chains.

Uses the address’s numeric value as a bytes32 identifier by casting type in-place.

function toIdentifier(address addr) internal pure returns (bytes32 identifier);

Parameters

Returns

fromIdentifier

Converts a bytes32 identifier back to an Ethereum address.

Reverses the toIdentifier operation by cleaning the top 96 bits and then returning the address remaining from the last 160 bits.

function fromIdentifier(bytes32 identifier) internal pure returns (address addr);

Parameters

Returns

fromIdentifier

Converts a uint256 identifier back to an Ethereum address.

Reverses the toIdentifier operation by cleaning the top 96 bits and then returning the address remaining from the last 160 bits.

function fromIdentifier(uint256 identifier) internal pure returns (address addr);

Parameters

Returns

safeFromIdentifier

Converts a uint256 identifier to an Ethereum address while requiring that the leftmost 12 bytes are empty.

Reverts if any bit is set in the leftmost 12 bytes. Then typecasts transparently.

function safeFromIdentifier(uint256 identifier) internal pure returns (address addr);

Parameters

Returns

Errors

InvalidAddress

The input isn’t safely coerced to an address

error InvalidAddress();

LibToken

Git Source

Constants

NATIVE_TOKEN

ERC7528 Address Convention

address public constant NATIVE_TOKEN = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)

Functions

isNativeToken

function isNativeToken(address token) internal pure returns (bool result);

Contents

• Call
• LibCall
• Order
• OrderInput
• OrderOutput
• RelayedOrderOutput
• LibOrder

Call

Git Source

Arbitrary protocol call

struct Call {
address target; // Protocol contract
uint256 value; // Native value to forward
bytes data; // Encoded function call
}

LibCall

Git Source

Constants

CALL_TYPE

bytes constant CALL_TYPE = abi.encodePacked("Call(address target,uint256 value,bytes data)")

CALL_TYPE_HASH

bytes32 constant CALL_TYPE_HASH = keccak256(CALL_TYPE)

Functions

callContract

function callContract(Call calldata call) internal returns (bytes memory result);

tryCall

function tryCall(Call calldata call) internal returns (bool success, bool exceededMaxCopy, bytes memory result);

hash

Raw hash of Call data WITHOUT type hash — utility function

For EIP712-compliant hashing, use hashType() instead

function hash(Call calldata call) public pure returns (bytes32 callHash);

hashType

EIP712 hashStruct for Call — includes CALL_TYPE_HASH

Matches: hashStruct(Call) = keccak256(CALL_TYPE_HASH ‖ encodeData(Call))

function hashType(Call calldata call) public pure returns (bytes32 callHash);

hash

Generates a deterministic hash for a Call[]

function hash(Call[] calldata calls) public pure returns (bytes32 callsHash);

Parameters

Returns

hashType

EIP712 hashStruct for Call[]

function hashType(Call[] calldata calls) public pure returns (bytes32 callsHash);

Parameters

Returns

Order

Git Source

Minimal order focused on inputs and execution

struct Order {
// Identity (deterministic from inputs, not calls)
address user; // Who provides inputs
uint256 nonce; // Replay protection
uint256 deadline; // Latest timestamp for valid execution

// Assets to consume
OrderInput[] inputs; // Assets sponsor provides
OrderOutput[] outputs; // Expected outputs to be processed

// Protocol execution (black box)
Call[] calls; // Ordered protocol calls to execute
bytes callSig; // Authorizing signature of calls

bytes metadata; // Optional: tags, offchain references, referrals, etc.
}

OrderInput

Git Source

Input asset specification

struct OrderInput {
address token; // ERC7528 followed for native (see {LibToken})
uint256 amount; // Exact amount to pull
}

OrderOutput

Git Source

Output asset specification

struct OrderOutput {
bytes32 recipient; // Cross-chain friendly address
bytes32 token; // Output token
uint256 amount; // Amount received
bytes callData; // Calldata to forward to `recipient`, can be empty
// TODO: Should context be here for order types? Or defer to separate contract?
}

RelayedOrderOutput

Git Source

Output tracking (used by Receiver)

struct RelayedOrderOutput {
bytes32 orderId; // Links back to source order
bytes32 recipient; // Cross-chain friendly address
bytes32 token; // Output token
uint256 amount; // Amount received
bytes callData; // Calldata to forward to `recipient`, can be empty
// TODO: Should context be here for order types? Or defer to separate contract?
}

LibOrder

Git Source

Constants

ORDER_ROUTE_TYPE

bytes constant ORDER_ROUTE_TYPE =
    abi.encodePacked("OrderRoute(bytes32 orderId,uint256 deadline,Call[] calls)", LibCall.CALL_TYPE)

ORDER_ROUTE_TYPE_HASH

bytes32 constant ORDER_ROUTE_TYPE_HASH = keccak256(ORDER_ROUTE_TYPE)

ORDER_INPUT_TYPE

bytes constant ORDER_INPUT_TYPE = abi.encodePacked("OrderInput(address token,uint256 amount)")

ORDER_INPUT_TYPE_HASH

bytes32 constant ORDER_INPUT_TYPE_HASH = keccak256(ORDER_INPUT_TYPE)

ORDER_OUTPUT_TYPE

bytes constant ORDER_OUTPUT_TYPE =
    abi.encodePacked("OrderOutput(bytes32 orderId,bytes32 recipient,bytes32 token,uint256 amount,bytes callData)")

ORDER_OUTPUT_TYPE_HASH

bytes32 constant ORDER_OUTPUT_TYPE_HASH = keccak256(ORDER_OUTPUT_TYPE)

Functions

orderId

function orderId(Order calldata order) public view returns (bytes32 id);

hash

Raw hash of Order calls — utility, NOT EIP712-compliant

For EIP712-compliant hashing, use hashType() instead

function hash(Order calldata order) public view returns (bytes32 routeHash);

hashType

EIP712 hashStruct for OrderRoute — includes ORDER_ROUTE_TYPE_HASH

Matches: hashStruct(OrderRoute) = keccak256(ORDER_ROUTE_TYPE_HASH ‖ orderId ‖ encodeData(Call[])) where encodeData(Call[]) = keccak256(hashType(calls[0]) ‖ hashType(calls[1]) ‖ …)

function hashType(Order calldata order) public view returns (bytes32 routeHash);

hash

Generates a deterministic hash for an OrderInput WITHOUT type hash signature

function hash(OrderInput calldata input) public pure returns (bytes32 inputHash);

Parameters

Returns

hashType

Generates a deterministic hash for an OrderInput

function hashType(OrderInput calldata input) public pure returns (bytes32 inputHash);

Parameters

Returns

hash

Generates a deterministic hash for an OrderInput[]

function hash(OrderInput[] calldata inputs) public pure returns (bytes32 inputsHash);

Parameters

Returns

hash

Generates a deterministic hash for an OrderOutput WITHOUT type hash signature

function hash(OrderOutput calldata output) public pure returns (bytes32 outputHash);

Parameters

Returns

hashType

Generates a deterministic hash for a RelayedOrderOutput

function hashType(RelayedOrderOutput calldata output) public pure returns (bytes32 outputHash);

Parameters

Returns

Contents

• VaultFallback

VaultFallback

Git Source

Constants

_FALLBACK_TRANSFERRED_EVENT_SIGNATURE

keccak256(bytes("FallbackTransferred(address,address)")).

uint256 private constant _FALLBACK_TRANSFERRED_EVENT_SIGNATURE =
    0x76b6ff30b9c54394454c961c5c1860e047b141beb52f06e45509097109524797

_VAULT_SLOT

The fallback vault slot is given by: bytes32(~uint256(uint32(bytes4(keccak256("_VAULT_SLOT_NOT"))))). It is intentionally chosen to be a high value to avoid collision with lower slots. The choice of manual storage layout is to enable compatibility with both regular and upgradeable contracts.

bytes32 internal constant _VAULT_SLOT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbaf973c6

Functions

_initializeVault

function _initializeVault(address newVault) internal virtual;

_setVault

function _setVault(address newVault) internal virtual;

_sendToVault

Send ALL remaining funds to treasury

function _sendToVault(address token) internal;

Parameters

vault

function vault() public view virtual returns (address result);

Events

FallbackTransferred

The vault fallback is transferred from oldVault to newVault.

event FallbackTransferred(address indexed oldVault, address indexed newVault);

Errors

VaultIsZeroAddress

The vault to be set cannot be the zero address

error VaultIsZeroAddress();

AcrossAdapter

Git Source

Inherits: BaseAdapter

Title: AcrossAdapter

Adapter for settling Across bridge claims and forwarding to MetaIntentReceiver

Receives bridged tokens directly from Across and forwards actual received amounts

Functions

constructor

constructor(address receiver) BaseAdapter(receiver);

settle

Settle bridged tokens and forward actual received amount to MetaIntentReceiver

function settle(RelayedOrderOutput calldata expectedOutput) external payable returns (bytes32 payloadHash);

Parameters

Returns

_fulfillToReceiverWithAmount

Internal helper to fulfill to receiver with a specific amount

This allows us to use the expectedOutput structure but with the actual received amount

function _fulfillToReceiverWithAmount(RelayedOrderOutput calldata baseOutput, uint256 actualAmount)
    internal
    returns (bytes32 payloadHash);

_decodeMessage

Override _decodeMessage for BaseAdapter compliance

function _decodeMessage(bytes calldata message) internal pure override returns (RelayedOrderOutput memory output);

Parameters

Returns

receive

receive() external payable override;

Errors

InsufficientSettlementAmount

error InsufficientSettlementAmount(uint256 received, uint256 expected);

BaseAdapter

Git Source

Inherits: Adapter

Title: BaseAdapter

Base contract for adapters that connect underlying protocols to the MetaIntentReceiver.

Provides reusable functions for connecting with the MetaIntentReceiver, including token transfer helpers and message decoding patterns. Protocol-specific adapters should inherit from this contract and override the virtual functions to implement their specific requirements.

Constants

RECEIVER

The MetaIntentReceiver that this adapter forwards fulfillments to

Receiver public immutable RECEIVER

Functions

constructor

constructor(address receiverAddr) ;

Parameters

onlyProtocol

modifier onlyProtocol() ;

receiver

Returns the MetaIntentReceiver address this adapter forwards to

function receiver() external view returns (address receiverAddr);

Returns

_decodeMessage

Decode a protocol-specific message into RelayedOrderOutput

Virtual function that must be overridden by protocol-specific adapters. This internal version allows adapters to use the decoding logic internally.

function _decodeMessage(bytes calldata message) internal virtual returns (RelayedOrderOutput memory output);

Parameters

Returns

_onlyProtocol

Modifier pattern for protocol-specific access control

Override this function to add authorization checks. For example, override to only allow specific protocol bridge contracts to call. Empty by default - implementations should override for production use.

function _onlyProtocol() internal virtual;

_fulfillToReceiver

Transfer tokens to receiver and call fulfill

Handles both native and ERC20 token transfers to the receiver, then calls fulfill() on the MetaIntentReceiver. Follows CEI pattern: checks (balance validation) happen in receiver.

function _fulfillToReceiver(RelayedOrderOutput calldata output) internal returns (bytes32 payloadHash);

Parameters

Returns

receive

receive() external payable virtual;

Errors

NativeTransferFailed

Revert when native token transfer to receiver fails

error NativeTransferFailed();

ReceiverIsZeroAddress

Revert when receiver address is zero

error ReceiverIsZeroAddress();

MayanAdapter

Git Source

Inherits: BaseAdapter

Title: MayanAdapter

Adapter for settling Mayan protocol claims and forwarding to MetaIntentReceiver

Uses pull configuration - any third-party settler can trigger settlements

Constants

MAYAN_CIRCLE

MayanCircle public immutable MAYAN_CIRCLE

FAST_MCTP

FastMCTP public immutable FAST_MCTP

SWIFT_DEST

SwiftDest public immutable SWIFT_DEST

CCTP_TOKEN_INDEX

uint256 internal constant CCTP_TOKEN_INDEX = 120

CCTP_RECIPIENT_INDEX

uint256 internal constant CCTP_RECIPIENT_INDEX = 152

CCTPV2_MESSAGE_BODY_INDEX

uint256 internal constant CCTPV2_MESSAGE_BODY_INDEX = 148

CCTPV2_SOURCE_TOKEN_INDEX

uint256 internal constant CCTPV2_SOURCE_TOKEN_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 4

HOOK_DATA_INDEX

uint256 internal constant HOOK_DATA_INDEX = CCTPV2_MESSAGE_BODY_INDEX + 228

Functions

constructor

Constructor sets immutable references to Mayan contracts and receiver

constructor(address receiver, address payable mayanCircle, address payable fastMctp, address payable swiftDest)
    BaseAdapter(receiver);

Parameters

settleMayanCircle

Settle tokens from MayanCircle and forward to MetaIntentReceiver

function settleMayanCircle(
    bytes calldata cctpMsg,
    bytes calldata cctpSigs,
    bytes calldata encodedVm,
    MayanCircle.BridgeWithFeeParams calldata bridgeParams,
    RelayedOrderOutput calldata expectedOutput
) external payable returns (bytes32 payloadHash);

Parameters

Returns

settleFastMCTP

Settle tokens from FastMCTP and forward to MetaIntentReceiver

function settleFastMCTP(bytes calldata cctpMsg, bytes calldata cctpSigs, RelayedOrderOutput calldata expectedOutput)
    external
    payable
    returns (bytes32 payloadHash);

Parameters

Returns

settleSwiftDest

Settle tokens from SwiftDest and forward to MetaIntentReceiver

function settleSwiftDest(
    OrderParams calldata params,
    ExtraParams calldata extraParams,
    RelayedOrderOutput calldata expectedOutput
) external returns (bytes32 payloadHash);

Parameters

Returns

_extractTokenFromCctpV1Msg

Extract token address from CCTP V1 message (MayanCircle)

function _extractTokenFromCctpV1Msg(bytes calldata cctpMsg) internal pure returns (address token);

Parameters

Returns

_extractTokenFromCctpV2Msg

Extract token address from CCTP V2 message (FastMCTP)

function _extractTokenFromCctpV2Msg(bytes calldata cctpMsg) internal pure returns (address token);

Parameters

Returns

_extractOrderIdFromCctpV2Msg

Extract orderId from CCTP V2 message hook data (FastMCTP)

Hook data format: payloadType(1) + destAddr(32) + gasDrop(8) + redeemFee(8) + referrerAddr(32) + referrerBps(1) + customPayload(32) Total: 84 bytes before customPayload, customPayload at index HOOK_DATA_INDEX + 82

function _extractOrderIdFromCctpV2Msg(bytes calldata cctpMsg) internal pure returns (bytes32 orderId);

Parameters

Returns

_fulfillToReceiverWithAmount

Internal helper to fulfill to receiver with a specific amount

This allows us to use the expectedOutput structure but with the actual received amount

function _fulfillToReceiverWithAmount(RelayedOrderOutput calldata baseOutput, uint256 actualAmount)
    internal
    returns (bytes32 payloadHash);

Parameters

Returns

_decodeMessage

Override _decodeMessage for BaseAdapter compliance

function _decodeMessage(bytes calldata message) internal pure override returns (RelayedOrderOutput memory output);

Parameters

Returns

receive

receive() external payable override;

Errors

InvalidMayanContract

error InvalidMayanContract();

SettlementFailed

error SettlementFailed();

InsufficientSettlementAmount

error InsufficientSettlementAmount(uint256 received, uint256 expected);

InvalidCctpMessage

error InvalidCctpMessage();

OrderIdMismatch

error OrderIdMismatch(bytes32 expected, bytes32 actual);

TokenMismatch

error TokenMismatch(bytes32 expected, bytes32 actual);

MetaIntentReceiver

Git Source

Inherits: Receiver, ReentrancyGuard, OwnableRoles, Pausable, VaultFallback

Title: MetaIntentReceiver

Tracks order fulfillment on destination chain and handles token transfers to recipients

Called by underlying protocols (Across, UniswapX, etc.) to mark completion and transfer tokens

Constants

ADMIN_ROLE

Administrator role identifier

uint256 public constant ADMIN_ROLE = _ROLE_0

OPERATOR_ROLE

Operator role identifier

uint256 public constant OPERATOR_ROLE = _ROLE_1

State Variables

_fulfillments

Track which outputs have been fulfilled with their payload hashes

mapping(bytes32 orderId => mapping(bytes32 outputHash => bytes32 payloadHash)) _fulfillments

Functions

constructor

constructor(address owner, address operator, address vault) ;

fulfill

Fulfill an order output by transferring tokens to the recipient

function fulfill(RelayedOrderOutput calldata output)
    external
    // onlyAuthorized
    whenNotPaused
    nonReentrant
    returns (bytes32 payloadHash);

Parameters

Returns

setVault

function setVault(address newVault) external onlyRoles(ADMIN_ROLE);

pause

Pause the contract, preventing state change calls

Can only be called by an administrator

function pause() external onlyRoles(OPERATOR_ROLE);

unpause

Unpause the contract, allowing state change calls

Can only be called by an administrator

function unpause() external onlyRoles(OPERATOR_ROLE);

outputFulfilled

Check if a specific output hash exists for an order

function outputFulfilled(bytes32 orderId, bytes32 outputHash) external view returns (bool exists);

Parameters

Returns

outputPayloadHash

Get the payload hash for a fulfilled output

function outputPayloadHash(bytes32 orderId, bytes32 outputHash) external view returns (bytes32 result);

Parameters

Returns

_payloadHash

Calculate payload hash for an output

function _payloadHash(bytes32 protocolId, uint32 timestamp) internal pure returns (bytes32 hash);

Parameters

Returns

_processCall

Process call and handle fallback on failure

function _processCall(RelayedOrderOutput calldata output) private;

Parameters

_relayToRecipient

Send funds and relay optional calldata to recipient

Calldata can only be relayed iff recipient is a contract

function _relayToRecipient(RelayedOrderOutput calldata output) internal;

Parameters

receive

receive() external payable;

Events

OutputFulfilled

Emitted when a single output is fulfilled

event OutputFulfilled(
    bytes32 indexed orderId,
    bytes32 indexed outputHash,
    bytes32 indexed payloadHash,
    bytes32 recipient,
    bytes32 token,
    uint256 amount,
    address filler
);

MetaIntentTransmitter

Git Source

Inherits: Transmitter, ReentrancyGuard, OwnableRoles, Pausable, EIP712

Title: MetaIntentTransmitter

One-way order issuer that:

1. Pulls inputs from user
2. Executes protocol calls in order
3. Emits event and exits

Constants

OPERATOR_ROLE

Operator role identifier

uint256 public constant OPERATOR_ROLE = _ROLE_0

AUTHORITY_ROLE

Authority role identifier

uint256 public constant AUTHORITY_ROLE = _ROLE_1

TOKEN_STACK_SLOT

Note: storage-location: erc7201:metaintenttransmitter.tokens

bytes32 constant TOKEN_STACK_SLOT = 0x1b08c89f51b1decc132fa8988a44ec87df810cdce8fa337e2d1606c8b95fe100

State Variables

_nonces

Prevent nonce reuse per user

mapping(address user => mapping(uint256 nonce => bytes32 orderId)) _nonces

_executedOrders

Track order execution for analytics

mapping(bytes32 orderId => uint256 nonce) _executedOrders

routeAuthority

Address for authorizing routes

address public routeAuthority

Functions

constructor

constructor(address owner, address operator, address authorizer, address initialRouteAuthority) EIP712();

execute

Execute a meta-intent order by pulling inputs and executing protocol calls

function execute(Order calldata order) external payable whenNotPaused nonReentrant returns (bytes32 orderId);

Parameters

Returns

pause

Pause the contract, preventing state change calls

Can only be called by an administrator

function pause() external onlyRoles(OPERATOR_ROLE);

unpause

Unpause the contract, allowing state change calls

Can only be called by an administrator

function unpause() external onlyRoles(OPERATOR_ROLE);

setRouteAuthority

Update the route authority address

Can only be called by an administrator

function setRouteAuthority(address newRouteAuthority) external onlyRoles(AUTHORITY_ROLE);

Parameters

previewOrderId

Compute orderId without executing (for front-end)

function previewOrderId(Order calldata order) external view returns (bytes32);

orderConsumed

Check if an order has been consumed

function orderConsumed(bytes32 orderId) public view returns (bool);

nonceConsumed

Check if nonce has been used

function nonceConsumed(address user, uint256 nonce) public view returns (bool);

_consumeNonce

Consume a nonce for user and associate it with orderId

function _consumeNonce(address user, uint256 nonce, bytes32 orderId) internal;

_refundExcess

If return any current balance to msg.sender

function _refundExcess(address to) internal;

_verifyCallSignature

Verifies that the call signature is valid for the given order

Uses EIP712 domain hashing and SignatureCheckerLib for verification

function _verifyCallSignature(Order calldata order) internal view;

Parameters

_domainNameAndVersion

function _domainNameAndVersion() internal pure override returns (string memory name, string memory version);

_tokens

function _tokens() internal pure returns (LibTransient.TStack storage ptr);

_pushAddr

function _pushAddr(LibTransient.TStack storage tokens, address addr) internal;

_popAddr

function _popAddr(LibTransient.TStack storage tokens) internal returns (address addr);

_setRouteAuthority

function _setRouteAuthority(address newRouteAuthority) internal;

Events

OrderInitiated

Emitted when order is successfully initialized

Off-chain systems index this to track order lifecycle

event OrderInitiated(bytes32 indexed orderId, address indexed user, uint256 timestamp);

RouteAuthorityUpdated

Emitted when the route authority address is rotated

Off-chain systems index this to track signer changes

event RouteAuthorityUpdated(address indexed oldAuthority, address indexed newAuthority);

Delegate

Git Source

Inherits: ERC165Upgradeable, ReentrancyGuardUpgradeable, AccessControlUpgradeable, Delegatable

Author: Mure Implements AccessControlUpgradeable for access control, UUPSUpgradeable for efficient upgrades, ERC165Upgradeable for interface support, and Delegatable for plugin compatibility. Manages storage for delegated functions, including user share per pool, pool configurations, pool contract,and plugins. Also provides hooks for custom functionality in pool-related operations. Delegate handles the various plugins that might be required by a particular application, for example, for reward claims and for fees deduction. Each application can subscribe to one or more plugins which will then link to the delegate for that application and be available to use. NOTE: A single instance of a delegate shall be bound to a single instance of the pool contract.

Abstract contract governing delegated functionality for the applications in Mure protocol.

Constants

DelegateStorageLocation

Struct hash for storage location keccak256(abi.encode(uint256(keccak256("mure.Delegate")) - 1)) & ~bytes32(uint256(0xff))

bytes32 internal constant DelegateStorageLocation =
    0xc4200f32c1c30cddd40d021baa377d96970df44812e3c252691c8e5d8633a500

CLAIM

Defines if the claim plugin is enabled

uint16 constant CLAIM = 0x01

DELEGATE_OPERATOR_ROLE

Role allows user to create and update pools along with pool administration

bytes32 public constant DELEGATE_OPERATOR_ROLE = keccak256("DELEGATE_OPERATOR")

Functions

onlyPool

modifier onlyPool() ;

validPool

modifier validPool(string calldata poolName) ;

onlyPlugin

modifier onlyPlugin() ;

pluginEnabled

modifier pluginEnabled(string calldata poolName, uint16 plugin) ;

pluginDisabled

modifier pluginDisabled(string calldata poolName, uint16 plugin) ;

onlyCustodianOrOwner

modifier onlyCustodianOrOwner(string calldata poolName) ;

__Delegate_init

Initializes the contract setting owner, poolContract, and claimPlugin.

function __Delegate_init(address owner, address poolContract_, address claimPlugin_) internal onlyInitializing;

withdrawPoolFunds

Places a delegated call to withdraw pool funds.

pauses the pool and locks refunds

function withdrawPoolFunds(string calldata poolName) external onlyCustodianOrOwner(poolName);

Parameters

depositPoolFunds

Deposits the withdrawn pool funds back. This operation assumes that the contract is an approved spender of the depositor.

Transfers the original collected funds back to the pool app. Additional funds stay on the delegate

Unpauses the pool and unlocks refunds

function depositPoolFunds(string calldata poolName, uint256 depositFunds, uint256 claimFunds)
    external
    onlyCustodianOrOwner(poolName)
    nonReentrant;

Parameters

share

Returns the user depositor value.

function share(string calldata poolName, address depositor) external view returns (uint256);

Parameters

state

Returns the pool config state.

function state(string calldata poolName) external view returns (PoolConfig memory);

Parameters

claim

Processes user claims.

function claim(string calldata poolName) external pluginEnabled(poolName, CLAIM) validPool(poolName);

Parameters

activateClaimPlugin

Activates the claim plugin.

function activateClaimPlugin(string calldata poolName, address claimCurrency)
    external
    onlyRole(DELEGATE_OPERATOR_ROLE)
    validPool(poolName);

Parameters

deactivateClaimPlugin

Deactivates the claim plugin.

function deactivateClaimPlugin(string calldata poolName)
    external
    onlyRole(DELEGATE_OPERATOR_ROLE)
    validPool(poolName);

Parameters

setPoolClaimCurrency

Sets the pool claim currency.

function setPoolClaimCurrency(string calldata poolName, address currency)
    external
    onlyRole(DELEGATE_OPERATOR_ROLE)
    validPool(poolName);

Parameters

setPoolFeePercentage

Sets the pools fee percentage.

Can only be called if the fee plugin is enabled.

Fee percentage is in basis points (1 = 0.01%).

function setPoolFeePercentage(string calldata poolName, uint16 feePercentage)
    external
    onlyRole(DELEGATE_OPERATOR_ROLE)
    validPool(poolName);

Parameters

setPoolContract

Sets the pool app address.

Set as address(0) to deprecate delegate.

function setPoolContract(address poolContract) external onlyRole(DELEGATE_OPERATOR_ROLE);

Parameters

setClaimPlugin

Sets the claim plugin address.

function setClaimPlugin(address pluginAddress) external onlyRole(DELEGATE_OPERATOR_ROLE);

Parameters

deposit

Places a delegated call to deposit on the pool app. This operation assumes that the pool app is an approved spender of the depositor.

function deposit(string calldata poolName, DepositArgs calldata depositArgs) external nonReentrant;

Parameters

refund

Places a delegated call for refund on the pool app.

function refund(string calldata poolName) external nonReentrant pluginDisabled(poolName, CLAIM);

Parameters

refund

Places a delegated call for refund on the pool app.

function refund(string calldata poolName, address depositor, uint256 amount) external nonReentrant onlyPlugin;

Parameters

sendFunds

Transfers funds to a specific address.

Can only be called by a verified plugin.

function sendFunds(address to, uint256 amount, address currency) external onlyPlugin nonReentrant;

Parameters

previewClaim

Returns the refund amount, claim amount and fee.

function previewClaim(string calldata poolName, address depositor)
    external
    view
    returns (uint256 depositDelta, uint256 claimDelta, uint256 fee);

Parameters

Returns

beforeDeposit

Hook to be called by the pool app before a deposit.

function beforeDeposit(string calldata poolName, uint256 amount, address depositor, bytes memory sig)
    external
    virtual
    onlyPool;

Parameters

afterDeposit

Hook to be called by the pool app after a deposit.

function afterDeposit(string calldata poolName, uint256 amount, address depositor, bytes memory sig)
    external
    virtual
    onlyPool;

Parameters

beforeRefund

Hook to be called by the pool app before a refund.

function beforeRefund(string calldata poolName, address depositor) external virtual onlyPool;

Parameters

afterRefund

Hook to be called by the pool app after a refund.

function afterRefund(string calldata poolName, address depositor, uint256 amount) external virtual onlyPool;

Parameters

withdrawCurrency

Withdraw any token from the contract. This should only be used in emergencies as this can withdraw capital from any pool, be it active or not. Always prefer using withdraw over this function, unless you need clean up the contract by, e.g., burning garbage tokens.

function withdrawCurrency(address receiver, address currency) external onlyRole(DELEGATE_OPERATOR_ROLE);

Parameters

poolConfig

Retrieves the config of the specified pool.

function poolConfig(string calldata poolName) external view returns (PoolConfig memory);

Parameters

poolAddress

Retrieves the pool app address.

function poolAddress() external view returns (address);

claimPluginAddress

Retrieves the claim plugin address.

function claimPluginAddress() external view returns (address);

isPoolActive

Checks if the specified pool is active.

function isPoolActive(string calldata poolName) external view returns (bool);

Parameters

withdrawableAmount

Checks if the specified pool is active.

function withdrawableAmount(string calldata poolName) external view returns (uint112);

Parameters

poolState

Retrieves the state of the specified pool.

Requires the pool to exist.

function poolState(string calldata poolName) external view returns (PoolState memory);

Parameters

deposited

Retrieves the amount deposited by the specified depositor in the specified pool.

Requires the pool to exist.

function deposited(string calldata poolName, address depositor) external view returns (uint256);

Parameters

poolExists

Checks if the specified pool exists.

function poolExists(string calldata poolName) external view returns (bool);

Parameters

getClaimCurrency

Returns the address of the claim currency for a pool.

function getClaimCurrency(string calldata poolName) external view returns (address);

Parameters

supportsInterface

See IERC165-supportsInterface.

function supportsInterface(bytes4 interfaceId)
    public
    view
    virtual
    override (ERC165Upgradeable, IERC165, AccessControlUpgradeable)
    returns (bool);

_transferCurrency

Transfers currency between two addresses with a specified amount of a given currency.

function _transferCurrency(address from, address to, uint256 amount, address currency) internal;

Parameters

_refund

function _refund(address poolContract, string calldata poolName, address depositor, uint256 amount) internal;

_addSupply

function _addSupply(string calldata poolName, address depositor, uint256 supply) internal;

_deductSupply

function _deductSupply(string calldata poolName, address depositor, uint256 supply) internal;

_claim

function _claim(string calldata poolName, uint256 totalCollected, address custodian, uint256 userDeposit) internal;

_pluginEnabled

Checks whether a specific plugin is enabled.

function _pluginEnabled(uint16 plugins, uint16 plugin) internal pure returns (bool);

Parameters

_activatePlugin

Activates the specified plugin.

function _activatePlugin(uint16 plugins, uint16 plugin) internal pure returns (uint16);

Parameters

_deactivatePlugin

Deactivates the specified plugin.

function _deactivatePlugin(uint16 plugins, uint16 plugin) internal pure returns (uint16);

Parameters