Source Code
Overview
ETH Balance
0 ETH
ETH Value
$0.00View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Cross-Chain Transactions
Loading...
Loading
Contract Name:
TokenBridgeCctpV2
Compiler Version
v0.8.22+commit.4fc1097e
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
import {TokenBridgeCctpBase} from "./TokenBridgeCctpBase.sol";
import {TokenRouter} from "./libs/TokenRouter.sol";
import {TypedMemView} from "./../libs/TypedMemView.sol";
import {Message} from "./../libs/Message.sol";
import {TokenMessage} from "./libs/TokenMessage.sol";
import {CctpMessageV2, BurnMessageV2} from "../libs/CctpMessageV2.sol";
import {TypeCasts} from "../libs/TypeCasts.sol";
import {IMessageHandlerV2} from "../interfaces/cctp/IMessageHandlerV2.sol";
import {ITokenMessengerV2} from "../interfaces/cctp/ITokenMessengerV2.sol";
import {IMessageTransmitterV2} from "../interfaces/cctp/IMessageTransmitterV2.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
// @dev Supports only CCTP V2
contract TokenBridgeCctpV2 is TokenBridgeCctpBase, IMessageHandlerV2 {
using CctpMessageV2 for bytes29;
using BurnMessageV2 for bytes29;
using TypedMemView for bytes29;
using Message for bytes;
using TypeCasts for bytes32;
error MaxFeeTooHigh();
// see https://developers.circle.com/cctp/cctp-finality-and-fees#defined-finality-thresholds
uint32 public immutable minFinalityThreshold;
uint256 public immutable maxFeeBps;
constructor(
address _erc20,
address _mailbox,
IMessageTransmitterV2 _messageTransmitter,
ITokenMessengerV2 _tokenMessenger,
uint256 _maxFeeBps,
uint32 _minFinalityThreshold
)
TokenBridgeCctpBase(
_erc20,
_mailbox,
_messageTransmitter,
_tokenMessenger
)
{
if (_maxFeeBps >= 10_000) revert MaxFeeTooHigh();
maxFeeBps = _maxFeeBps;
minFinalityThreshold = _minFinalityThreshold;
}
// ============ TokenRouter overrides ============
/**
* @inheritdoc TokenRouter
* @dev Overrides to indicate v2 fees.
*
* Hyperlane uses a "minimum amount out" approach where users specify the exact amount
* they want the recipient to receive on the destination chain. This provides a better
* UX by guaranteeing predictable outcomes regardless of underlying bridge fee structures.
*
* However, some underlying bridges like CCTP charge fees as a percentage of the input
* amount (amountIn), not the output amount. This requires "reversing" the fee calculation:
* we need to determine what input amount (after fees are deducted) will result in the
* desired output amount reaching the recipient.
*
* The formula solves for the fee needed such that after Circle takes their percentage,
* the recipient receives exactly `amount`:
*
* (amount + fee) * (10_000 - maxFeeBps) / 10_000 = amount
*
* Solving for fee:
* fee = (amount * maxFeeBps) / (10_000 - maxFeeBps)
*
* Example: If amount = 100 USDC and maxFeeBps = 10 (0.1%):
* fee = (100 * 10) / (10_000 - 10) = 1000 / 9990 ≈ 0.1001 USDC
* We deposit 100.1001 USDC, Circle takes 0.1001 USDC, recipient gets exactly 100 USDC.
*/
function _externalFeeAmount(
uint32,
bytes32,
uint256 amount
) internal view override returns (uint256 feeAmount) {
// round up because depositForBurn maxFee is an upper bound
// enforced offchain by the Iris attestation service without precision loss
return
Math.mulDiv(
amount,
maxFeeBps,
10_000 - maxFeeBps,
Math.Rounding.Up
);
}
function _getCCTPVersion() internal pure override returns (uint32) {
return 1;
}
function _getCircleRecipient(
bytes29 cctpMessage
) internal pure override returns (address) {
return cctpMessage._getRecipient().bytes32ToAddress();
}
function _validateTokenMessage(
bytes calldata hyperlaneMessage,
bytes29 cctpMessage
) internal pure override {
bytes29 burnMessage = cctpMessage._getMessageBody();
burnMessage._validateBurnMessageFormat();
bytes32 circleBurnSender = burnMessage._getMessageSender();
if (circleBurnSender != hyperlaneMessage.sender())
revert InvalidBurnSender();
bytes calldata tokenMessage = hyperlaneMessage.body();
if (TokenMessage.amount(tokenMessage) != burnMessage._getAmount())
revert InvalidMintAmount();
if (
TokenMessage.recipient(tokenMessage) !=
burnMessage._getMintRecipient()
) revert InvalidMintRecipient();
}
function _validateHookMessage(
bytes calldata hyperlaneMessage,
bytes29 cctpMessage
) internal pure override {
bytes32 circleMessageId = cctpMessage._getMessageBody().index(0, 32);
if (circleMessageId != hyperlaneMessage.id()) revert InvalidMessageId();
}
// @inheritdoc IMessageHandlerV2
function handleReceiveFinalizedMessage(
uint32 sourceDomain,
bytes32 sender,
uint32 /*finalityThresholdExecuted*/,
bytes calldata messageBody
) external override returns (bool) {
return
_receiveMessageId(
sourceDomain,
sender,
abi.decode(messageBody, (bytes32))
);
}
// @inheritdoc IMessageHandlerV2
function handleReceiveUnfinalizedMessage(
uint32 sourceDomain,
bytes32 sender,
uint32 /*finalityThresholdExecuted*/,
bytes calldata messageBody
) external override returns (bool) {
return
_receiveMessageId(
sourceDomain,
sender,
abi.decode(messageBody, (bytes32))
);
}
function _sendMessageIdToIsm(
uint32 destinationDomain,
bytes32 ism,
bytes32 messageId
) internal override {
IMessageTransmitterV2(address(messageTransmitter)).sendMessage(
destinationDomain,
ism,
ism,
minFinalityThreshold,
abi.encode(messageId)
);
}
function _bridgeViaCircle(
uint32 circleDomain,
bytes32 _recipient,
uint256 _amount,
uint256 _maxFee,
bytes32 _ism
) internal override {
ITokenMessengerV2(address(tokenMessenger)).depositForBurn(
_amount,
circleDomain,
_recipient,
address(wrappedToken),
_ism,
_maxFee,
minFinalityThreshold
);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
import {TokenRouter} from "./libs/TokenRouter.sol";
import {HypERC20Collateral} from "./HypERC20Collateral.sol";
import {IMessageTransmitter} from "./../interfaces/cctp/IMessageTransmitter.sol";
import {IInterchainSecurityModule} from "./../interfaces/IInterchainSecurityModule.sol";
import {AbstractCcipReadIsm} from "./../isms/ccip-read/AbstractCcipReadIsm.sol";
import {TypedMemView} from "./../libs/TypedMemView.sol";
import {ITokenMessenger} from "./../interfaces/cctp/ITokenMessenger.sol";
import {Message} from "./../libs/Message.sol";
import {TokenMessage} from "./libs/TokenMessage.sol";
import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
import {StandardHookMetadata} from "../hooks/libs/StandardHookMetadata.sol";
import {IMessageHandler} from "../interfaces/cctp/IMessageHandler.sol";
import {TypeCasts} from "../libs/TypeCasts.sol";
import {MovableCollateralRouter, MovableCollateralRouterStorage} from "./libs/MovableCollateralRouter.sol";
import {TokenRouter} from "./libs/TokenRouter.sol";
import {AbstractPostDispatchHook} from "../hooks/libs/AbstractPostDispatchHook.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
interface CctpService {
function getCCTPAttestation(
bytes calldata _message
)
external
view
returns (bytes memory cctpMessage, bytes memory attestation);
}
// need intermediate contract to insert slots between TokenRouter and AbstractCcipReadIsm
abstract contract TokenBridgeCctpBaseStorage is TokenRouter {
/// @dev This is used to enable storage layout backwards compatibility. It should not be read or written to.
MovableCollateralRouterStorage private __MOVABLE_COLLATERAL_GAP;
}
struct Domain {
uint32 hyperlane;
uint32 circle;
}
// see ./CCTP.md for sequence diagrams of the destination chain control flow
abstract contract TokenBridgeCctpBase is
TokenBridgeCctpBaseStorage,
AbstractCcipReadIsm,
AbstractPostDispatchHook
{
using Message for bytes;
using TypeCasts for bytes32;
using SafeERC20 for IERC20;
// using custom errors for bytecode size limitations
// end users will not see these in their wallet (at config and process time)
error InvalidCCTPVersion();
error CircleDomainNotConfigured();
error HyperlaneDomainNotConfigured();
error InvalidTokenMessageRecipient();
error InvalidCircleRecipient();
error NotMessageTransmitter();
error UnauthorizedCircleSender();
error MessageNotDispatched();
error InvalidBurnSender();
error InvalidMintAmount();
error InvalidMintRecipient();
error InvalidMessageId();
uint256 private constant _SCALE = 1;
IERC20 public immutable wrappedToken;
// @notice CCTP message transmitter contract
IMessageTransmitter public immutable messageTransmitter;
// @notice CCTP token messenger contract
ITokenMessenger public immutable tokenMessenger;
/// @notice Hyperlane domain => Domain struct.
/// We use a struct to avoid ambiguity with domain 0 being unknown.
mapping(uint32 hypDomain => Domain circleDomain)
internal _hyperlaneDomainMap;
/// @notice Circle domain => Domain struct.
// We use a struct to avoid ambiguity with domain 0 being unknown.
mapping(uint32 circleDomain => Domain hyperlaneDomain)
internal _circleDomainMap;
/// @notice Maps messageId to whether or not the message has been verified
/// by the CCTP message transmitter
mapping(bytes32 messageId => bool verified) public isVerified;
/**
* @notice Emitted when the Hyperlane domain to Circle domain mapping is updated.
* @param hyperlaneDomain The Hyperlane domain.
* @param circleDomain The Circle domain.
*/
event DomainAdded(uint32 indexed hyperlaneDomain, uint32 circleDomain);
constructor(
address _erc20,
address _mailbox,
IMessageTransmitter _messageTransmitter,
ITokenMessenger _tokenMessenger
) TokenRouter(_SCALE, _mailbox) {
if (_messageTransmitter.version() != _getCCTPVersion())
revert InvalidCCTPVersion();
messageTransmitter = _messageTransmitter;
if (_tokenMessenger.messageBodyVersion() != _getCCTPVersion())
revert InvalidCCTPVersion();
tokenMessenger = _tokenMessenger;
wrappedToken = IERC20(_erc20);
_disableInitializers();
}
/**
* @inheritdoc TokenRouter
*/
function token() public view override returns (address) {
return address(wrappedToken);
}
function initialize(
address _hook,
address _owner,
string[] memory __urls
) external initializer {
// ISM should not be set
_MailboxClient_initialize(_hook, address(0), _owner);
// Setup urls for offchain lookup and do token approval
setUrls(__urls);
wrappedToken.approve(address(tokenMessenger), type(uint256).max);
}
/**
* @inheritdoc TokenRouter
* @dev Overrides to bridge the tokens via Circle.
*/
function transferRemote(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) public payable override returns (bytes32 messageId) {
// 1. Calculate the fee amounts, charge the sender and distribute to feeRecipient if necessary
(
uint256 externalFee,
uint256 remainingNativeValue
) = _calculateFeesAndCharge(
_destination,
_recipient,
_amount,
msg.value
);
// 2. Prepare the token message with the recipient, amount, and any additional metadata in overrides
bytes32 ism = _mustHaveRemoteRouter(_destination);
uint32 circleDomain = hyperlaneDomainToCircleDomain(_destination);
uint256 burnAmount = _amount + externalFee;
_bridgeViaCircle(
circleDomain,
_recipient,
burnAmount,
externalFee,
ism
);
bytes memory _message = TokenMessage.format(_recipient, burnAmount);
// 3. Emit the SentTransferRemote event and 4. dispatch the message
return
_emitAndDispatch(
_destination,
_recipient,
_amount, // no scaling needed for CCTP
remainingNativeValue,
_message
);
}
function interchainSecurityModule()
external
view
override
returns (IInterchainSecurityModule)
{
return IInterchainSecurityModule(address(this));
}
/**
* @notice Adds a new mapping between a Hyperlane domain and a Circle domain.
* @param _hyperlaneDomain The Hyperlane domain.
* @param _circleDomain The Circle domain.
*/
function addDomain(
uint32 _hyperlaneDomain,
uint32 _circleDomain
) public onlyOwner {
_hyperlaneDomainMap[_hyperlaneDomain] = Domain(
_hyperlaneDomain,
_circleDomain
);
_circleDomainMap[_circleDomain] = Domain(
_hyperlaneDomain,
_circleDomain
);
emit DomainAdded(_hyperlaneDomain, _circleDomain);
}
function addDomains(Domain[] memory domains) external onlyOwner {
for (uint32 i = 0; i < domains.length; i++) {
addDomain(domains[i].hyperlane, domains[i].circle);
}
}
function hyperlaneDomainToCircleDomain(
uint32 _hyperlaneDomain
) public view returns (uint32) {
Domain memory domain = _hyperlaneDomainMap[_hyperlaneDomain];
if (domain.hyperlane != _hyperlaneDomain)
revert CircleDomainNotConfigured();
return domain.circle;
}
function circleDomainToHyperlaneDomain(
uint32 _circleDomain
) public view returns (uint32) {
Domain memory domain = _circleDomainMap[_circleDomain];
if (domain.circle != _circleDomain)
revert HyperlaneDomainNotConfigured();
return domain.hyperlane;
}
function _getCCTPVersion() internal pure virtual returns (uint32);
function _getCircleRecipient(
bytes29 cctpMessage
) internal pure virtual returns (address);
function _validateTokenMessage(
bytes calldata hyperlaneMessage,
bytes29 cctpMessage
) internal pure virtual;
function _validateHookMessage(
bytes calldata hyperlaneMessage,
bytes29 cctpMessage
) internal pure virtual;
function _sendMessageIdToIsm(
uint32 destinationDomain,
bytes32 ism,
bytes32 messageId
) internal virtual;
/**
* @dev Verifies that the CCTP message matches the Hyperlane message.
*/
function verify(
bytes calldata _metadata,
bytes calldata _hyperlaneMessage
) external returns (bool) {
// check if hyperlane message has already been verified by CCTP
if (isVerified[_hyperlaneMessage.id()]) {
return true;
}
// decode return type of CctpService.getCCTPAttestation
(bytes memory cctpMessageBytes, bytes memory attestation) = abi.decode(
_metadata,
(bytes, bytes)
);
bytes29 cctpMessage = TypedMemView.ref(cctpMessageBytes, 0);
address circleRecipient = _getCircleRecipient(cctpMessage);
// check if CCTP message is a USDC burn message
if (circleRecipient == address(tokenMessenger)) {
// prevent hyperlane message recipient configured with CCTP ISM
// from verifying and handling token messages
if (_hyperlaneMessage.recipientAddress() != address(this))
revert InvalidTokenMessageRecipient();
_validateTokenMessage(_hyperlaneMessage, cctpMessage);
}
// check if CCTP message is a GMP message to this contract
else if (circleRecipient == address(this)) {
_validateHookMessage(_hyperlaneMessage, cctpMessage);
}
// disallow other CCTP message destinations
else {
revert InvalidCircleRecipient();
}
// for GMP messages, this.verifiedMessages[hyperlaneMessage.id()] will be set
// for token messages, hyperlaneMessage.body().amount() tokens will be delivered to hyperlaneMessage.body().recipient()
return messageTransmitter.receiveMessage(cctpMessageBytes, attestation);
}
function _receiveMessageId(
uint32 circleSource,
bytes32 circleSender,
bytes32 messageId
) internal returns (bool) {
if (msg.sender != address(messageTransmitter))
revert NotMessageTransmitter();
// ensure that the message was sent from the hook on the origin chain
uint32 origin = circleDomainToHyperlaneDomain(circleSource);
if (_mustHaveRemoteRouter(origin) != circleSender)
revert UnauthorizedCircleSender();
isVerified[messageId] = true;
return true;
}
function _offchainLookupCalldata(
bytes calldata _message
) internal pure override returns (bytes memory) {
return abi.encodeCall(CctpService.getCCTPAttestation, (_message));
}
/// @inheritdoc IPostDispatchHook
function hookType() external pure override returns (uint8) {
return uint8(IPostDispatchHook.HookTypes.CCTP);
}
/// @inheritdoc AbstractPostDispatchHook
function _quoteDispatch(
bytes calldata /*metadata*/,
bytes calldata /*message*/
) internal pure override returns (uint256) {
return 0;
}
/// @inheritdoc AbstractPostDispatchHook
/// @dev Mirrors the logic in AbstractMessageIdAuthHook._postDispatch
// but using Router table instead of hook <> ISM coupling
function _postDispatch(
bytes calldata metadata,
bytes calldata message
) internal override {
bytes32 id = message.id();
if (!_isLatestDispatched(id)) revert MessageNotDispatched();
uint32 destination = message.destination();
bytes32 ism = _mustHaveRemoteRouter(destination);
uint32 circleDestination = hyperlaneDomainToCircleDomain(destination);
_sendMessageIdToIsm(circleDestination, ism, id);
_refund(metadata, message, address(this).balance);
}
/**
* @inheritdoc TokenRouter
* @dev Overrides to transfer the tokens from the sender to this contract (like HypERC20Collateral).
*/
function _transferFromSender(uint256 _amount) internal override {
wrappedToken.safeTransferFrom(msg.sender, address(this), _amount);
}
/**
* @inheritdoc TokenRouter
* @dev Overrides to not transfer the tokens to the recipient, as the CCTP transfer will do it.
*/
function _transferTo(
address _recipient,
uint256 _amount
) internal override {
// do not transfer to recipient as the CCTP transfer will do it
}
/**
* @inheritdoc TokenRouter
* @dev Overrides to transfer fees directly from the router balance since CCTP handles token delivery.
*/
function _transferFee(
address _recipient,
uint256 _amount
) internal override {
wrappedToken.safeTransfer(_recipient, _amount);
}
function _bridgeViaCircle(
uint32 _destination,
bytes32 _recipient,
uint256 _amount,
uint256 _maxFee,
bytes32 _ism
) internal virtual;
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
// ============ Internal Imports ============
import {TypeCasts} from "../../libs/TypeCasts.sol";
import {GasRouter} from "../../client/GasRouter.sol";
import {TokenMessage} from "./TokenMessage.sol";
import {Quote, ITokenBridge, ITokenFee} from "../../interfaces/ITokenBridge.sol";
import {Quotes} from "./Quotes.sol";
import {StorageSlot} from "@openzeppelin/contracts/utils/StorageSlot.sol";
/**
* @title Hyperlane Token Router that extends Router with abstract token (ERC20/ERC721) remote transfer functionality.
* @dev Overridable functions:
* - token(): specify the managed token address
* - _transferFromSender(uint256): pull tokens/ETH from msg.sender
* - _transferTo(address,uint256): send tokens/ETH to the recipient
* - _externalFeeAmount(uint32,bytes32,uint256): compute external fees (default returns 0)
* @dev Override transferRemote only to implement custom logic that can't be accomplished with the above functions.
*
* @author Abacus Works
*/
abstract contract TokenRouter is GasRouter, ITokenBridge {
using TypeCasts for bytes32;
using TypeCasts for address;
using TokenMessage for bytes;
using StorageSlot for bytes32;
using Quotes for Quote[];
/**
* @dev Emitted on `transferRemote` when a transfer message is dispatched.
* @param destination The identifier of the destination chain.
* @param recipient The address of the recipient on the destination chain.
* @param amountOrId The amount or ID of tokens sent in to the remote recipient.
*/
event SentTransferRemote(
uint32 indexed destination,
bytes32 indexed recipient,
uint256 amountOrId
);
/**
* @dev Emitted on `_handle` when a transfer message is processed.
* @param origin The identifier of the origin chain.
* @param recipient The address of the recipient on the destination chain.
* @param amountOrId The amount or ID of tokens received from the remote sender.
*/
event ReceivedTransferRemote(
uint32 indexed origin,
bytes32 indexed recipient,
uint256 amountOrId
);
uint256 public immutable scale;
// cannot use compiler assigned slot without
// breaking backwards compatibility of storage layout
bytes32 private constant FEE_RECIPIENT_SLOT =
keccak256("FungibleTokenRouter.feeRecipient");
event FeeRecipientSet(address feeRecipient);
constructor(uint256 _scale, address _mailbox) GasRouter(_mailbox) {
scale = _scale;
}
// ===========================
// ========== Main API ==========
// ===========================
/**
* @notice Returns the address of the token managed by this router. It can be one of three options:
* - ERC20 token address for fungible tokens that are being collateralized (HypERC20Collateral, HypERC4626, etc.)
* - 0x0 address for native tokens (ETH, MATIC, etc.) (HypNative, etc.)
* - address(this) for synthetic ERC20 tokens (HypERC20, etc.)
* It is being used for quotes and fees from the fee recipient and pulling/push the tokens from the sender/receipient.
* @dev This function must be implemented by derived contracts to specify the token address.
* @return The address of the token contract.
*/
function token() public view virtual returns (address);
/**
* @inheritdoc ITokenFee
* @notice Implements the standardized fee quoting interface for token transfers based on
* overridable internal functions of _quoteGasPayment, _feeRecipientAndAmount, and _externalFeeAmount.
* @param _destination The identifier of the destination chain.
* @param _recipient The address of the recipient on the destination chain.
* @param _amount The amount or identifier of tokens to be sent to the remote recipient
* @return quotes An array of Quote structs representing the fees in different tokens.
* @dev This function may return multiple quotes with the same denomination. Convention is to return:
* [index 0] native fees charged by the mailbox dispatch
* [index 1] then any internal warp route fees (amount bridged plus fee recipient)
* [index 2] then any external bridging fees (if any, else 0)
* These are surfaced as separate elements to enable clients to interpret/render fees independently.
* There is a Quotes library with an extract function for onchain quoting in a specific denomination,
* but we discourage onchain quoting in favor of offchain quoting and overpaying with refunds.
*/
function quoteTransferRemote(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) external view override returns (Quote[] memory quotes) {
quotes = new Quote[](3);
quotes[0] = Quote({
token: address(0),
amount: _quoteGasPayment(_destination, _recipient, _amount)
});
(, uint256 feeAmount) = _feeRecipientAndAmount(
_destination,
_recipient,
_amount
);
quotes[1] = Quote({token: token(), amount: _amount + feeAmount});
quotes[2] = Quote({
token: token(),
amount: _externalFeeAmount(_destination, _recipient, _amount)
});
}
/**
* @notice Transfers `_amount` token to `_recipient` on the `_destination` domain.
* @dev Delegates transfer logic to `_transferFromSender` implementation.
* Emits `SentTransferRemote` event on the origin chain.
* Override with custom behavior for storing or forwarding tokens.
* Known overrides:
* - OPL2ToL1TokenBridgeNative: adds hook metadata for message dispatch.
* - EverclearTokenBridge: creates Everclear intent for cross-chain token transfer.
* - TokenBridgeCctpBase: adds CCTP-specific metadata for message dispatch.
* - HypERC4626Collateral: deposits into vault and handles shares.
* When overriding, mirror the general flow of this function for consistency:
* 1. Calculate fees and charge the sender.
* 2. Prepare the token message with recipient, amount, and any additional metadata.
* 3. Emit `SentTransferRemote` event.
* 4. Dispatch the message.
* @param _destination The identifier of the destination chain.
* @param _recipient The address of the recipient on the destination chain.
* @param _amount The amount or identifier of tokens to be sent to the remote recipient.
* @return messageId The identifier of the dispatched message.
*/
function transferRemote(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) public payable virtual returns (bytes32 messageId) {
// 1. Calculate the fee amounts, charge the sender and distribute to feeRecipient if necessary
(, uint256 remainingNativeValue) = _calculateFeesAndCharge(
_destination,
_recipient,
_amount,
msg.value
);
uint256 scaledAmount = _outboundAmount(_amount);
// 2. Prepare the token message with the recipient and amount
bytes memory _tokenMessage = TokenMessage.format(
_recipient,
scaledAmount
);
// 3. Emit the SentTransferRemote event and 4. dispatch the message
return
_emitAndDispatch(
_destination,
_recipient,
scaledAmount,
remainingNativeValue,
_tokenMessage
);
}
// ===========================
// ========== Internal convenience functions for readability ==========
// ==========================
function _calculateFeesAndCharge(
uint32 _destination,
bytes32 _recipient,
uint256 _amount,
uint256 _msgValue
) internal returns (uint256 externalFee, uint256 remainingNativeValue) {
(address _feeRecipient, uint256 feeAmount) = _feeRecipientAndAmount(
_destination,
_recipient,
_amount
);
externalFee = _externalFeeAmount(_destination, _recipient, _amount);
uint256 charge = _amount + feeAmount + externalFee;
_transferFromSender(charge);
if (feeAmount > 0) {
// transfer atomically so we don't need to keep track of collateral
// and fee balances separately
_transferFee(_feeRecipient, feeAmount);
}
remainingNativeValue = token() != address(0)
? _msgValue
: _msgValue - charge;
}
// Emits the SentTransferRemote event and dispatches the message.
function _emitAndDispatch(
uint32 _destination,
bytes32 _recipient,
uint256 _amount,
uint256 _messageDispatchValue,
bytes memory _tokenMessage
) internal returns (bytes32 messageId) {
// effects
emit SentTransferRemote(_destination, _recipient, _amount);
// interactions
messageId = _Router_dispatch(
_destination,
_messageDispatchValue,
_tokenMessage,
_GasRouter_hookMetadata(_destination),
address(hook)
);
}
// ===========================
// ========== Fees & Quoting ==========
// ===========================
/**
* @notice Sets the fee recipient for the router.
* @dev Allows for address(0) to be set, which disables fees.
* @param recipient The address that receives fees.
*/
function setFeeRecipient(address recipient) public onlyOwner {
require(recipient != address(this), "Fee recipient cannot be self");
FEE_RECIPIENT_SLOT.getAddressSlot().value = recipient;
emit FeeRecipientSet(recipient);
}
/**
* @notice Returns the address of the fee recipient.
* @dev Returns address(0) if no fee recipient is set.
* @dev Can be overridden with address(0) to disable fees entirely.
* @return address of the fee recipient.
*/
function feeRecipient() public view virtual returns (address) {
return FEE_RECIPIENT_SLOT.getAddressSlot().value;
}
// To be overridden by derived contracts if they have additional fees
/**
* @notice Returns the external fee amount for the given parameters.
* param _destination The identifier of the destination chain.
* param _recipient The address of the recipient on the destination chain.
* param _amount The amount or identifier of tokens to be sent to the remote recipient
* @return feeAmount The external fee amount.
* @dev This fee must be denominated in the `token()` defined by this router.
* @dev The default implementation returns 0, meaning no external fees are charged.
* This function is intended to be overridden by derived contracts that have additional fees.
* Known overrides:
* - TokenBridgeCctpBase: for CCTP-specific fees
* - EverclearTokenBridge: for Everclear-specific fees
*/
function _externalFeeAmount(
uint32, // _destination,
bytes32, // _recipient,
uint256 // _amount
) internal view virtual returns (uint256 feeAmount) {
return 0;
}
/**
* @notice Returns the fee recipient amount for the given parameters.
* @param _destination The identifier of the destination chain.
* @param _recipient The address of the recipient on the destination chain.
* @param _amount The amount or identifier of tokens to be sent to the remote recipient
* @return _feeRecipient The address of the fee recipient.
* @return feeAmount The fee recipient amount.
* @dev This function is is not intended to be overridden as storage and logic is contained in TokenRouter.
*/
function _feeRecipientAndAmount(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) internal view returns (address _feeRecipient, uint256 feeAmount) {
_feeRecipient = feeRecipient();
if (_feeRecipient == address(0)) {
return (_feeRecipient, 0);
}
Quote[] memory quotes = ITokenFee(_feeRecipient).quoteTransferRemote(
_destination,
_recipient,
_amount
);
if (quotes.length == 0) {
return (_feeRecipient, 0);
}
require(
quotes.length == 1 && quotes[0].token == token(),
"FungibleTokenRouter: fee must match token"
);
feeAmount = quotes[0].amount;
}
/**
* @notice Returns the gas payment required to dispatch a message to the given domain's router.
* @param _destination The identifier of the destination chain.
* @param _recipient The address of the recipient on the destination chain.
* @param _amount The amount or identifier of tokens to be sent to the remote recipient
* @return payment How much native value to send in transferRemote call.
* @dev This function is intended to be overridden by derived contracts that trigger multiple messages.
* Known overrides:
* - OPL2ToL1TokenBridgeNative: Quote for two messages (prove and finalize).
*/
function _quoteGasPayment(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) internal view virtual returns (uint256) {
return
_Router_quoteDispatch(
_destination,
TokenMessage.format(_recipient, _amount),
_GasRouter_hookMetadata(_destination),
address(hook)
);
}
// ===========================
// ========== Internal virtual functions for token handling ==========
// ===========================
/**
* @dev Should transfer `_amount` of tokens from `msg.sender` to this token router.
* Called by `transferRemote` before message dispatch.
* Known overrides:
* - HypERC20: Burns the tokens from the sender.
* - HypERC20Collateral: Pulls the tokens from the sender.
* - HypNative: Asserts msg.value >= _amount
* - TokenBridgeCctpBase: (like HypERC20Collateral) Pulls the tokens from the sender.
* - EverclearEthTokenBridge: Wraps the native token (ETH) to WETH
* - HypERC4626: Converts the amounts to shares and burns from the User (via HypERC20 implementation)
* - HypFiatToken: Pulls the tokens from the sender and burns them on the FiatToken contract.
* - HypXERC20: Burns the tokens from the sender.
* - HypXERC20Lockbox: Pulls the tokens from the sender, locks them in the XERC20Lockbox contract and burns the resulting xERC20 tokens.
*/
function _transferFromSender(uint256 _amountOrId) internal virtual;
/**
* @dev Should transfer `_amountOrId` of tokens from this token router to `_recipient`.
* @dev Called by `handle` after message decoding.
* Known overrides:
* - HypERC20: Mints the tokens to the recipient.
* - HypERC20Collateral: Releases the tokens to the recipient.
* - HypNative: Releases native tokens to the recipient.
* - TokenBridgeCctpBase: Do nothing (CCTP transfers tokens to the recipient directly).
* - EverclearEthTokenBridge: Unwraps WETH to ETH and sends to the recipient.
* - HypERC4626: Converts the amount to shares and mints to the User (via HypERC20 implementation)
* - HypFiatToken: Mints the tokens to the recipient on the FiatToken contract.
* - HypXERC20: Mints the tokens to the recipient.
* - HypXERC20Lockbox: Withdraws the underlying tokens from the Lockbox and sends to the recipient.
* - OpL1NativeTokenBridge: Do nothing (the L2 bridge transfers the native tokens to the recipient directly).
*/
function _transferTo(
address _recipient,
uint256 _amountOrId
) internal virtual;
/**
* @dev Should transfer `_amount` of tokens from this token router to the fee recipient.
* @dev Called by `_calculateFeesAndCharge` when fee recipient is set and feeAmount > 0.
* @dev The default implementation delegates to `_transferTo`, which works for most token routers
* where tokens are held by the router (e.g., collateral routers, synthetic token routers).
* @dev Override this function for bridges where tokens are NOT held by the router but fees still
* need to be paid (e.g., CCTP, Everclear). In those cases, use direct token transfers from the
* router's balance collected via `_transferFromSender`.
* Known overrides:
* - TokenBridgeCctpBase: Directly transfers tokens from router balance.
* - EverclearTokenBridge: Directly transfers tokens from router balance.
*/
function _transferFee(
address _recipient,
uint256 _amount
) internal virtual {
_transferTo(_recipient, _amount);
}
/**
* @dev Scales local amount to message amount (up by scale factor).
* Known overrides:
* - HypERC4626: Scales by exchange rate
*/
function _outboundAmount(
uint256 _localAmount
) internal view virtual returns (uint256 _messageAmount) {
_messageAmount = _localAmount * scale;
}
/**
* @dev Scales message amount to local amount (down by scale factor).
* Known overrides:
* - HypERC4626: Scales by exchange rate
*/
function _inboundAmount(
uint256 _messageAmount
) internal view virtual returns (uint256 _localAmount) {
_localAmount = _messageAmount / scale;
}
/**
* @notice Handles the incoming transfer message.
* It decodes the message, emits the ReceivedTransferRemote event, and transfers tokens to the recipient.
* @param _origin The identifier of the origin chain.
* @dev param _sender The address of the sender router on the origin chain.
* @param _message The message data containing recipient and amount.
* @dev Override this function if custom logic is required for sending out the tokens.
* Known overrides:
* - EverclearTokenBridge: Receives the tokens and sends them to the recipient.
* - EverclearEthBridge: Receives WETH, unwraps it and sends native ETH to the recipient.
* - HypERC4626: Updates the exchange rate from the metadata
*/
// solhint-disable-next-line hyperlane/no-virtual-override
function _handle(
uint32 _origin,
bytes32,
bytes calldata _message
) internal virtual override {
bytes32 recipient = _message.recipient();
uint256 amount = _message.amount();
// effects
emit ReceivedTransferRemote(_origin, recipient, amount);
// interactions
_transferTo(recipient.bytes32ToAddress(), _inboundAmount(amount));
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.12;
library TypedMemView {
// Why does this exist?
// the solidity `bytes memory` type has a few weaknesses.
// 1. You can't index ranges effectively
// 2. You can't slice without copying
// 3. The underlying data may represent any type
// 4. Solidity never deallocates memory, and memory costs grow
// superlinearly
// By using a memory view instead of a `bytes memory` we get the following
// advantages:
// 1. Slices are done on the stack, by manipulating the pointer
// 2. We can index arbitrary ranges and quickly convert them to stack types
// 3. We can insert type info into the pointer, and typecheck at runtime
// This makes `TypedMemView` a useful tool for efficient zero-copy
// algorithms.
// Why bytes29?
// We want to avoid confusion between views, digests, and other common
// types so we chose a large and uncommonly used odd number of bytes
//
// Note that while bytes are left-aligned in a word, integers and addresses
// are right-aligned. This means when working in assembly we have to
// account for the 3 unused bytes on the righthand side
//
// First 5 bytes are a type flag.
// - ff_ffff_fffe is reserved for unknown type.
// - ff_ffff_ffff is reserved for invalid types/errors.
// next 12 are memory address
// next 12 are len
// bottom 3 bytes are empty
// Assumptions:
// - non-modification of memory.
// - No Solidity updates
// - - wrt free mem point
// - - wrt bytes representation in memory
// - - wrt memory addressing in general
// Usage:
// - create type constants
// - use `assertType` for runtime type assertions
// - - unfortunately we can't do this at compile time yet :(
// - recommended: implement modifiers that perform type checking
// - - e.g.
// - - `uint40 constant MY_TYPE = 3;`
// - - ` modifier onlyMyType(bytes29 myView) { myView.assertType(MY_TYPE); }`
// - instantiate a typed view from a bytearray using `ref`
// - use `index` to inspect the contents of the view
// - use `slice` to create smaller views into the same memory
// - - `slice` can increase the offset
// - - `slice can decrease the length`
// - - must specify the output type of `slice`
// - - `slice` will return a null view if you try to overrun
// - - make sure to explicitly check for this with `notNull` or `assertType`
// - use `equal` for typed comparisons.
// The null view
bytes29 public constant NULL =
hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
// Mask a low uint96
uint256 constant LOW_12_MASK = 0xffffffffffffffffffffffff;
// Shift constants
uint8 constant SHIFT_TO_LEN = 24;
uint8 constant SHIFT_TO_LOC = 96 + 24;
uint8 constant SHIFT_TO_TYPE = 96 + 96 + 24;
// For nibble encoding
bytes private constant NIBBLE_LOOKUP = "0123456789abcdef";
/**
* @notice Returns the encoded hex character that represents the lower 4 bits of the argument.
* @param _byte The byte
* @return _char The encoded hex character
*/
function nibbleHex(uint8 _byte) internal pure returns (uint8 _char) {
uint8 _nibble = _byte & 0x0f; // keep bottom 4, 0 top 4
_char = uint8(NIBBLE_LOOKUP[_nibble]);
}
/**
* @notice Returns a uint16 containing the hex-encoded byte.
* @param _b The byte
* @return encoded - The hex-encoded byte
*/
function byteHex(uint8 _b) internal pure returns (uint16 encoded) {
encoded |= nibbleHex(_b >> 4); // top 4 bits
encoded <<= 8;
encoded |= nibbleHex(_b); // lower 4 bits
}
/**
* @notice Encodes the uint256 to hex. `first` contains the encoded top 16 bytes.
* `second` contains the encoded lower 16 bytes.
*
* @param _b The 32 bytes as uint256
* @return first - The top 16 bytes
* @return second - The bottom 16 bytes
*/
function encodeHex(
uint256 _b
) internal pure returns (uint256 first, uint256 second) {
for (uint8 i = 31; i > 15; ) {
uint8 _byte = uint8(_b >> (i * 8));
first |= byteHex(_byte);
if (i != 16) {
first <<= 16;
}
unchecked {
i -= 1;
}
}
// abusing underflow here =_=
for (uint8 i = 15; i < 255; ) {
uint8 _byte = uint8(_b >> (i * 8));
second |= byteHex(_byte);
if (i != 0) {
second <<= 16;
}
unchecked {
i -= 1;
}
}
}
/**
* @notice Changes the endianness of a uint256.
* @dev https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
* @param _b The unsigned integer to reverse
* @return v - The reversed value
*/
function reverseUint256(uint256 _b) internal pure returns (uint256 v) {
v = _b;
// swap bytes
v =
((v >> 8) &
0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |
((v &
0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) <<
8);
// swap 2-byte long pairs
v =
((v >> 16) &
0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |
((v &
0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) <<
16);
// swap 4-byte long pairs
v =
((v >> 32) &
0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |
((v &
0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) <<
32);
// swap 8-byte long pairs
v =
((v >> 64) &
0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |
((v &
0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) <<
64);
// swap 16-byte long pairs
v = (v >> 128) | (v << 128);
}
/**
* @notice Create a mask with the highest `_len` bits set.
* @param _len The length
* @return mask - The mask
*/
function leftMask(uint8 _len) private pure returns (uint256 mask) {
// ugly. redo without assembly?
assembly {
// solhint-disable-previous-line no-inline-assembly
mask := sar(
sub(_len, 1),
0x8000000000000000000000000000000000000000000000000000000000000000
)
}
}
/**
* @notice Return the null view.
* @return bytes29 - The null view
*/
function nullView() internal pure returns (bytes29) {
return NULL;
}
/**
* @notice Check if the view is null.
* @return bool - True if the view is null
*/
function isNull(bytes29 memView) internal pure returns (bool) {
return memView == NULL;
}
/**
* @notice Check if the view is not null.
* @return bool - True if the view is not null
*/
function notNull(bytes29 memView) internal pure returns (bool) {
return !isNull(memView);
}
/**
* @notice Check if the view is of a valid type and points to a valid location
* in memory.
* @dev We perform this check by examining solidity's unallocated memory
* pointer and ensuring that the view's upper bound is less than that.
* @param memView The view
* @return ret - True if the view is valid
*/
function isValid(bytes29 memView) internal pure returns (bool ret) {
if (typeOf(memView) == 0xffffffffff) return false;
uint256 _end = end(memView);
assembly {
// solhint-disable-previous-line no-inline-assembly
ret := iszero(gt(_end, mload(0x40)))
}
}
/**
* @notice Require that a typed memory view be valid.
* @dev Returns the view for easy chaining.
* @param memView The view
* @return bytes29 - The validated view
*/
function assertValid(bytes29 memView) internal pure returns (bytes29) {
require(isValid(memView), "Validity assertion failed");
return memView;
}
/**
* @notice Return true if the memview is of the expected type. Otherwise false.
* @param memView The view
* @param _expected The expected type
* @return bool - True if the memview is of the expected type
*/
function isType(
bytes29 memView,
uint40 _expected
) internal pure returns (bool) {
return typeOf(memView) == _expected;
}
/**
* @notice Require that a typed memory view has a specific type.
* @dev Returns the view for easy chaining.
* @param memView The view
* @param _expected The expected type
* @return bytes29 - The view with validated type
*/
function assertType(
bytes29 memView,
uint40 _expected
) internal pure returns (bytes29) {
if (!isType(memView, _expected)) {
(, uint256 g) = encodeHex(uint256(typeOf(memView)));
(, uint256 e) = encodeHex(uint256(_expected));
string memory err = string(
abi.encodePacked(
"Type assertion failed. Got 0x",
uint80(g),
". Expected 0x",
uint80(e)
)
);
revert(err);
}
return memView;
}
/**
* @notice Return an identical view with a different type.
* @param memView The view
* @param _newType The new type
* @return newView - The new view with the specified type
*/
function castTo(
bytes29 memView,
uint40 _newType
) internal pure returns (bytes29 newView) {
// then | in the new type
uint256 _typeShift = SHIFT_TO_TYPE;
uint256 _typeBits = 40;
assembly {
// solhint-disable-previous-line no-inline-assembly
// shift off the top 5 bytes
newView := or(newView, shr(_typeBits, shl(_typeBits, memView)))
newView := or(newView, shl(_typeShift, _newType))
}
}
/**
* @notice Unsafe raw pointer construction. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @dev Unsafe raw pointer construction. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @param _type The type
* @param _loc The memory address
* @param _len The length
* @return newView - The new view with the specified type, location and length
*/
function unsafeBuildUnchecked(
uint256 _type,
uint256 _loc,
uint256 _len
) private pure returns (bytes29 newView) {
uint256 _uint96Bits = 96;
uint256 _emptyBits = 24;
assembly {
// solium-disable-previous-line security/no-inline-assembly
newView := shl(_uint96Bits, or(newView, _type)) // insert type
newView := shl(_uint96Bits, or(newView, _loc)) // insert loc
newView := shl(_emptyBits, or(newView, _len)) // empty bottom 3 bytes
}
}
/**
* @notice Instantiate a new memory view. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @dev Instantiate a new memory view. This should generally not be called
* directly. Prefer `ref` wherever possible.
* @param _type The type
* @param _loc The memory address
* @param _len The length
* @return newView - The new view with the specified type, location and length
*/
function build(
uint256 _type,
uint256 _loc,
uint256 _len
) internal pure returns (bytes29 newView) {
uint256 _end = _loc + _len;
assembly {
// solhint-disable-previous-line no-inline-assembly
if gt(_end, mload(0x40)) {
_end := 0
}
}
if (_end == 0) {
return NULL;
}
newView = unsafeBuildUnchecked(_type, _loc, _len);
}
/**
* @notice Instantiate a memory view from a byte array.
* @dev Note that due to Solidity memory representation, it is not possible to
* implement a deref, as the `bytes` type stores its len in memory.
* @param arr The byte array
* @param newType The type
* @return bytes29 - The memory view
*/
function ref(
bytes memory arr,
uint40 newType
) internal pure returns (bytes29) {
uint256 _len = arr.length;
uint256 _loc;
assembly {
// solhint-disable-previous-line no-inline-assembly
_loc := add(arr, 0x20) // our view is of the data, not the struct
}
return build(newType, _loc, _len);
}
/**
* @notice Return the associated type information.
* @param memView The memory view
* @return _type - The type associated with the view
*/
function typeOf(bytes29 memView) internal pure returns (uint40 _type) {
uint256 _shift = SHIFT_TO_TYPE;
assembly {
// solium-disable-previous-line security/no-inline-assembly
_type := shr(_shift, memView) // shift out lower 27 bytes
}
}
/**
* @notice Optimized type comparison. Checks that the 5-byte type flag is equal.
* @param left The first view
* @param right The second view
* @return bool - True if the 5-byte type flag is equal
*/
function sameType(
bytes29 left,
bytes29 right
) internal pure returns (bool) {
return (left ^ right) >> SHIFT_TO_TYPE == 0;
}
/**
* @notice Return the memory address of the underlying bytes.
* @param memView The view
* @return _loc - The memory address
*/
function loc(bytes29 memView) internal pure returns (uint96 _loc) {
uint256 _mask = LOW_12_MASK; // assembly can't use globals
uint256 _shift = SHIFT_TO_LOC;
assembly {
// solium-disable-previous-line security/no-inline-assembly
_loc := and(shr(_shift, memView), _mask)
}
}
/**
* @notice The number of memory words this memory view occupies, rounded up.
* @param memView The view
* @return uint256 - The number of memory words
*/
function words(bytes29 memView) internal pure returns (uint256) {
return (uint256(len(memView)) + 31) / 32;
}
/**
* @notice The in-memory footprint of a fresh copy of the view.
* @param memView The view
* @return uint256 - The in-memory footprint of a fresh copy of the view.
*/
function footprint(bytes29 memView) internal pure returns (uint256) {
return words(memView) * 32;
}
/**
* @notice The number of bytes of the view.
* @param memView The view
* @return _len - The length of the view
*/
function len(bytes29 memView) internal pure returns (uint96 _len) {
uint256 _mask = LOW_12_MASK; // assembly can't use globals
uint256 _emptyBits = 24;
assembly {
// solium-disable-previous-line security/no-inline-assembly
_len := and(shr(_emptyBits, memView), _mask)
}
}
/**
* @notice Returns the endpoint of `memView`.
* @param memView The view
* @return uint256 - The endpoint of `memView`
*/
function end(bytes29 memView) internal pure returns (uint256) {
unchecked {
return loc(memView) + len(memView);
}
}
/**
* @notice Safe slicing without memory modification.
* @param memView The view
* @param _index The start index
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function slice(
bytes29 memView,
uint256 _index,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
uint256 _loc = loc(memView);
// Ensure it doesn't overrun the view
if (_loc + _index + _len > end(memView)) {
return NULL;
}
_loc = _loc + _index;
return build(newType, _loc, _len);
}
/**
* @notice Shortcut to `slice`. Gets a view representing the first `_len` bytes.
* @param memView The view
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function prefix(
bytes29 memView,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
return slice(memView, 0, _len, newType);
}
/**
* @notice Shortcut to `slice`. Gets a view representing the last `_len` byte.
* @param memView The view
* @param _len The length
* @param newType The new type
* @return bytes29 - The new view
*/
function postfix(
bytes29 memView,
uint256 _len,
uint40 newType
) internal pure returns (bytes29) {
return slice(memView, uint256(len(memView)) - _len, _len, newType);
}
/**
* @notice Construct an error message for an indexing overrun.
* @param _loc The memory address
* @param _len The length
* @param _index The index
* @param _slice The slice where the overrun occurred
* @return err - The err
*/
function indexErrOverrun(
uint256 _loc,
uint256 _len,
uint256 _index,
uint256 _slice
) internal pure returns (string memory err) {
(, uint256 a) = encodeHex(_loc);
(, uint256 b) = encodeHex(_len);
(, uint256 c) = encodeHex(_index);
(, uint256 d) = encodeHex(_slice);
err = string(
abi.encodePacked(
"TypedMemView/index - Overran the view. Slice is at 0x",
uint48(a),
" with length 0x",
uint48(b),
". Attempted to index at offset 0x",
uint48(c),
" with length 0x",
uint48(d),
"."
)
);
}
/**
* @notice Load up to 32 bytes from the view onto the stack.
* @dev Returns a bytes32 with only the `_bytes` highest bytes set.
* This can be immediately cast to a smaller fixed-length byte array.
* To automatically cast to an integer, use `indexUint`.
* @param memView The view
* @param _index The index
* @param _bytes The bytes
* @return result - The 32 byte result
*/
function index(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (bytes32 result) {
if (_bytes == 0) return bytes32(0);
if (_index + _bytes > len(memView)) {
revert(
indexErrOverrun(
loc(memView),
len(memView),
_index,
uint256(_bytes)
)
);
}
require(
_bytes <= 32,
"TypedMemView/index - Attempted to index more than 32 bytes"
);
uint8 bitLength;
unchecked {
bitLength = _bytes * 8;
}
uint256 _loc = loc(memView);
uint256 _mask = leftMask(bitLength);
assembly {
// solhint-disable-previous-line no-inline-assembly
result := and(mload(add(_loc, _index)), _mask)
}
}
/**
* @notice Parse an unsigned integer from the view at `_index`.
* @dev Requires that the view have >= `_bytes` bytes following that index.
* @param memView The view
* @param _index The index
* @param _bytes The bytes
* @return result - The unsigned integer
*/
function indexUint(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (uint256 result) {
return uint256(index(memView, _index, _bytes)) >> ((32 - _bytes) * 8);
}
/**
* @notice Parse an unsigned integer from LE bytes.
* @param memView The view
* @param _index The index
* @param _bytes The bytes
* @return result - The unsigned integer
*/
function indexLEUint(
bytes29 memView,
uint256 _index,
uint8 _bytes
) internal pure returns (uint256 result) {
return reverseUint256(uint256(index(memView, _index, _bytes)));
}
/**
* @notice Parse an address from the view at `_index`. Requires that the view have >= 20 bytes
* following that index.
* @param memView The view
* @param _index The index
* @return address - The address
*/
function indexAddress(
bytes29 memView,
uint256 _index
) internal pure returns (address) {
return address(uint160(indexUint(memView, _index, 20)));
}
/**
* @notice Return the keccak256 hash of the underlying memory
* @param memView The view
* @return digest - The keccak256 hash of the underlying memory
*/
function keccak(bytes29 memView) internal pure returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
assembly {
// solhint-disable-previous-line no-inline-assembly
digest := keccak256(_loc, _len)
}
}
/**
* @notice Return the sha2 digest of the underlying memory.
* @dev We explicitly deallocate memory afterwards.
* @param memView The view
* @return digest - The sha2 hash of the underlying memory
*/
function sha2(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
bool res;
assembly {
// solhint-disable-previous-line no-inline-assembly
let ptr := mload(0x40)
res := staticcall(gas(), 2, _loc, _len, ptr, 0x20) // sha2 #1
digest := mload(ptr)
}
require(res, "sha2 OOG");
}
/**
* @notice Implements bitcoin's hash160 (rmd160(sha2()))
* @param memView The pre-image
* @return digest - the Digest
*/
function hash160(bytes29 memView) internal view returns (bytes20 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
bool res;
assembly {
// solhint-disable-previous-line no-inline-assembly
let ptr := mload(0x40)
res := staticcall(gas(), 2, _loc, _len, ptr, 0x20) // sha2
res := and(res, staticcall(gas(), 3, ptr, 0x20, ptr, 0x20)) // rmd160
digest := mload(add(ptr, 0xc)) // return value is 0-prefixed.
}
require(res, "hash160 OOG");
}
/**
* @notice Implements bitcoin's hash256 (double sha2)
* @param memView A view of the preimage
* @return digest - the Digest
*/
function hash256(bytes29 memView) internal view returns (bytes32 digest) {
uint256 _loc = loc(memView);
uint256 _len = len(memView);
bool res;
assembly {
// solhint-disable-previous-line no-inline-assembly
let ptr := mload(0x40)
res := staticcall(gas(), 2, _loc, _len, ptr, 0x20) // sha2 #1
res := and(res, staticcall(gas(), 2, ptr, 0x20, ptr, 0x20)) // sha2 #2
digest := mload(ptr)
}
require(res, "hash256 OOG");
}
/**
* @notice Return true if the underlying memory is equal. Else false.
* @param left The first view
* @param right The second view
* @return bool - True if the underlying memory is equal
*/
function untypedEqual(
bytes29 left,
bytes29 right
) internal pure returns (bool) {
return
(loc(left) == loc(right) && len(left) == len(right)) ||
keccak(left) == keccak(right);
}
/**
* @notice Return false if the underlying memory is equal. Else true.
* @param left The first view
* @param right The second view
* @return bool - False if the underlying memory is equal
*/
function untypedNotEqual(
bytes29 left,
bytes29 right
) internal pure returns (bool) {
return !untypedEqual(left, right);
}
/**
* @notice Compares type equality.
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param left The first view
* @param right The second view
* @return bool - True if the types are the same
*/
function equal(bytes29 left, bytes29 right) internal pure returns (bool) {
return
left == right ||
(typeOf(left) == typeOf(right) && keccak(left) == keccak(right));
}
/**
* @notice Compares type inequality.
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param left The first view
* @param right The second view
* @return bool - True if the types are not the same
*/
function notEqual(
bytes29 left,
bytes29 right
) internal pure returns (bool) {
return !equal(left, right);
}
/**
* @notice Copy the view to a location, return an unsafe memory reference
* @dev Super Dangerous direct memory access.
*
* This reference can be overwritten if anything else modifies memory (!!!).
* As such it MUST be consumed IMMEDIATELY.
* This function is private to prevent unsafe usage by callers.
* @param memView The view
* @param _newLoc The new location
* @return written - the unsafe memory reference
*/
function unsafeCopyTo(
bytes29 memView,
uint256 _newLoc
) private view returns (bytes29 written) {
require(notNull(memView), "TypedMemView/copyTo - Null pointer deref");
require(
isValid(memView),
"TypedMemView/copyTo - Invalid pointer deref"
);
uint256 _len = len(memView);
uint256 _oldLoc = loc(memView);
uint256 ptr;
bool res;
assembly {
// solhint-disable-previous-line no-inline-assembly
ptr := mload(0x40)
// revert if we're writing in occupied memory
if gt(ptr, _newLoc) {
revert(0x60, 0x20)
} // empty revert message
// use the identity precompile to copy
res := staticcall(gas(), 4, _oldLoc, _len, _newLoc, _len)
}
require(res, "identity OOG");
written = unsafeBuildUnchecked(typeOf(memView), _newLoc, _len);
}
/**
* @notice Copies the referenced memory to a new loc in memory, returning a `bytes` pointing to
* the new memory
* @dev Shortcuts if the pointers are identical, otherwise compares type and digest.
* @param memView The view
* @return ret - The view pointing to the new memory
*/
function clone(bytes29 memView) internal view returns (bytes memory ret) {
uint256 ptr;
uint256 _len = len(memView);
assembly {
// solhint-disable-previous-line no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
ret := ptr
}
unchecked {
unsafeCopyTo(memView, ptr + 0x20);
}
assembly {
// solhint-disable-previous-line no-inline-assembly
mstore(0x40, add(add(ptr, _len), 0x20)) // write new unused pointer
mstore(ptr, _len) // write len of new array (in bytes)
}
}
/**
* @notice Join the views in memory, return an unsafe reference to the memory.
* @dev Super Dangerous direct memory access.
*
* This reference can be overwritten if anything else modifies memory (!!!).
* As such it MUST be consumed IMMEDIATELY.
* This function is private to prevent unsafe usage by callers.
* @param memViews The views
* @param _location The location in memory to which to copy & concatenate
* @return unsafeView - The conjoined view pointing to the new memory
*/
function unsafeJoin(
bytes29[] memory memViews,
uint256 _location
) private view returns (bytes29 unsafeView) {
assembly {
// solhint-disable-previous-line no-inline-assembly
let ptr := mload(0x40)
// revert if we're writing in occupied memory
if gt(ptr, _location) {
revert(0x60, 0x20)
} // empty revert message
}
uint256 _offset = 0;
for (uint256 i = 0; i < memViews.length; i++) {
bytes29 memView = memViews[i];
unchecked {
unsafeCopyTo(memView, _location + _offset);
_offset += len(memView);
}
}
unsafeView = unsafeBuildUnchecked(0, _location, _offset);
}
/**
* @notice Produce the keccak256 digest of the concatenated contents of multiple views.
* @param memViews The views
* @return bytes32 - The keccak256 digest
*/
function joinKeccak(
bytes29[] memory memViews
) internal view returns (bytes32) {
uint256 ptr;
assembly {
// solhint-disable-previous-line no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
return keccak(unsafeJoin(memViews, ptr));
}
/**
* @notice Produce the sha256 digest of the concatenated contents of multiple views.
* @param memViews The views
* @return bytes32 - The sha256 digest
*/
function joinSha2(
bytes29[] memory memViews
) internal view returns (bytes32) {
uint256 ptr;
assembly {
// solhint-disable-previous-line no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
return sha2(unsafeJoin(memViews, ptr));
}
/**
* @notice copies all views, joins them into a new bytearray.
* @param memViews The views
* @return ret - The new byte array
*/
function join(
bytes29[] memory memViews
) internal view returns (bytes memory ret) {
uint256 ptr;
assembly {
// solhint-disable-previous-line no-inline-assembly
ptr := mload(0x40) // load unused memory pointer
}
bytes29 _newView;
unchecked {
_newView = unsafeJoin(memViews, ptr + 0x20);
}
uint256 _written = len(_newView);
uint256 _footprint = footprint(_newView);
assembly {
// solhint-disable-previous-line no-inline-assembly
// store the length
mstore(ptr, _written)
// new pointer is old + 0x20 + the footprint of the body
mstore(0x40, add(add(ptr, _footprint), 0x20))
ret := ptr
}
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
import {TypeCasts} from "./TypeCasts.sol";
/**
* @title Hyperlane Message Library
* @notice Library for formatted messages used by Mailbox
**/
library Message {
using TypeCasts for bytes32;
uint256 private constant VERSION_OFFSET = 0;
uint256 private constant NONCE_OFFSET = 1;
uint256 private constant ORIGIN_OFFSET = 5;
uint256 private constant SENDER_OFFSET = 9;
uint256 private constant DESTINATION_OFFSET = 41;
uint256 private constant RECIPIENT_OFFSET = 45;
uint256 private constant BODY_OFFSET = 77;
/**
* @notice Returns formatted (packed) Hyperlane message with provided fields
* @dev This function should only be used in memory message construction.
* @param _version The version of the origin and destination Mailboxes
* @param _nonce A nonce to uniquely identify the message on its origin chain
* @param _originDomain Domain of origin chain
* @param _sender Address of sender as bytes32
* @param _destinationDomain Domain of destination chain
* @param _recipient Address of recipient on destination chain as bytes32
* @param _messageBody Raw bytes of message body
* @return Formatted message
*/
function formatMessage(
uint8 _version,
uint32 _nonce,
uint32 _originDomain,
bytes32 _sender,
uint32 _destinationDomain,
bytes32 _recipient,
bytes calldata _messageBody
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_version,
_nonce,
_originDomain,
_sender,
_destinationDomain,
_recipient,
_messageBody
);
}
/**
* @notice Returns the message ID.
* @param _message ABI encoded Hyperlane message.
* @return ID of `_message`
*/
function id(bytes memory _message) internal pure returns (bytes32) {
return keccak256(_message);
}
/**
* @notice Returns the message version.
* @param _message ABI encoded Hyperlane message.
* @return Version of `_message`
*/
function version(bytes calldata _message) internal pure returns (uint8) {
return uint8(bytes1(_message[VERSION_OFFSET:NONCE_OFFSET]));
}
/**
* @notice Returns the message nonce.
* @param _message ABI encoded Hyperlane message.
* @return Nonce of `_message`
*/
function nonce(bytes calldata _message) internal pure returns (uint32) {
return uint32(bytes4(_message[NONCE_OFFSET:ORIGIN_OFFSET]));
}
/**
* @notice Returns the message origin domain.
* @param _message ABI encoded Hyperlane message.
* @return Origin domain of `_message`
*/
function origin(bytes calldata _message) internal pure returns (uint32) {
return uint32(bytes4(_message[ORIGIN_OFFSET:SENDER_OFFSET]));
}
/**
* @notice Returns the message sender as bytes32.
* @param _message ABI encoded Hyperlane message.
* @return Sender of `_message` as bytes32
*/
function sender(bytes calldata _message) internal pure returns (bytes32) {
return bytes32(_message[SENDER_OFFSET:DESTINATION_OFFSET]);
}
/**
* @notice Returns the message sender as address.
* @param _message ABI encoded Hyperlane message.
* @return Sender of `_message` as address
*/
function senderAddress(
bytes calldata _message
) internal pure returns (address) {
return sender(_message).bytes32ToAddress();
}
/**
* @notice Returns the message destination domain.
* @param _message ABI encoded Hyperlane message.
* @return Destination domain of `_message`
*/
function destination(
bytes calldata _message
) internal pure returns (uint32) {
return uint32(bytes4(_message[DESTINATION_OFFSET:RECIPIENT_OFFSET]));
}
/**
* @notice Returns the message recipient as bytes32.
* @param _message ABI encoded Hyperlane message.
* @return Recipient of `_message` as bytes32
*/
function recipient(
bytes calldata _message
) internal pure returns (bytes32) {
return bytes32(_message[RECIPIENT_OFFSET:BODY_OFFSET]);
}
/**
* @notice Returns the message recipient as address.
* @param _message ABI encoded Hyperlane message.
* @return Recipient of `_message` as address
*/
function recipientAddress(
bytes calldata _message
) internal pure returns (address) {
return recipient(_message).bytes32ToAddress();
}
/**
* @notice Returns the message body.
* @param _message ABI encoded Hyperlane message.
* @return Body of `_message`
*/
function body(
bytes calldata _message
) internal pure returns (bytes calldata) {
return bytes(_message[BODY_OFFSET:]);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
library TokenMessage {
uint8 internal constant RECIPIENT_OFFSET = 0;
uint8 internal constant AMOUNT_OFFSET = 32;
uint8 internal constant METADATA_OFFSET = 64;
function format(
bytes32 _recipient,
uint256 _amount,
bytes memory _metadata
) internal pure returns (bytes memory) {
return abi.encodePacked(_recipient, _amount, _metadata);
}
function format(
bytes32 _recipient,
uint256 _amount
) internal pure returns (bytes memory) {
return abi.encodePacked(_recipient, _amount);
}
function recipient(bytes calldata message) internal pure returns (bytes32) {
return bytes32(message[RECIPIENT_OFFSET:RECIPIENT_OFFSET + 32]);
}
function amount(bytes calldata message) internal pure returns (uint256) {
return uint256(bytes32(message[AMOUNT_OFFSET:AMOUNT_OFFSET + 32]));
}
// alias for ERC721
function tokenId(bytes calldata message) internal pure returns (uint256) {
return amount(message);
}
function metadata(
bytes calldata message
) internal pure returns (bytes calldata) {
return message[METADATA_OFFSET:];
}
}/*
* Copyright 2024 Circle Internet Group, Inc. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
import {TypedMemView} from "./TypedMemView.sol";
// @dev copied from https://github.com/circlefin/evm-cctp-contracts/blob/release-2025-03-11T143015/src/messages/v2/MessageV2.sol
// @dev We are using the 'latest-solidity' branch for @memview-sol, which supports solidity version
// greater or equal than 0.8.0
/**
* @title MessageV2 Library
* @notice Library for formatted v2 messages used by Relayer and Receiver.
*
* @dev The message body is dynamically-sized to support custom message body
* formats. Other fields must be fixed-size to avoid hash collisions.
* Each other input value has an explicit type to guarantee fixed-size.
* Padding: uintNN fields are left-padded, and bytesNN fields are right-padded.
*
* Field Bytes Type Index
* version 4 uint32 0
* sourceDomain 4 uint32 4
* destinationDomain 4 uint32 8
* nonce 32 bytes32 12
* sender 32 bytes32 44
* recipient 32 bytes32 76
* destinationCaller 32 bytes32 108
* minFinalityThreshold 4 uint32 140
* finalityThresholdExecuted 4 uint32 144
* messageBody dynamic bytes 148
* @dev Differences from v1:
* - Nonce is now bytes32 (vs. uint64)
* - minFinalityThreshold added
* - finalityThresholdExecuted added
**/
library CctpMessageV2 {
using TypedMemView for bytes;
using TypedMemView for bytes29;
// Indices of each field in message
uint8 private constant VERSION_INDEX = 0;
uint8 private constant SOURCE_DOMAIN_INDEX = 4;
uint8 private constant DESTINATION_DOMAIN_INDEX = 8;
uint8 private constant NONCE_INDEX = 12;
uint8 private constant SENDER_INDEX = 44;
uint8 private constant RECIPIENT_INDEX = 76;
uint8 private constant DESTINATION_CALLER_INDEX = 108;
uint8 private constant MIN_FINALITY_THRESHOLD_INDEX = 140;
uint8 private constant FINALITY_THRESHOLD_EXECUTED_INDEX = 144;
uint8 private constant MESSAGE_BODY_INDEX = 148;
bytes32 private constant EMPTY_NONCE = bytes32(0);
uint32 private constant EMPTY_FINALITY_THRESHOLD_EXECUTED = 0;
/**
* @notice Returns formatted (packed) message with provided fields
* @param _version the version of the message format
* @param _sourceDomain Domain of home chain
* @param _destinationDomain Domain of destination chain
* @param _sender Address of sender on source chain as bytes32
* @param _recipient Address of recipient on destination chain as bytes32
* @param _destinationCaller Address of caller on destination chain as bytes32
* @param _minFinalityThreshold the minimum finality at which the message should be attested to
* @param _messageBody Raw bytes of message body
* @return Formatted message
**/
function _formatMessageForRelay(
uint32 _version,
uint32 _sourceDomain,
uint32 _destinationDomain,
bytes32 _sender,
bytes32 _recipient,
bytes32 _destinationCaller,
uint32 _minFinalityThreshold,
bytes memory _messageBody
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_version,
_sourceDomain,
_destinationDomain,
EMPTY_NONCE,
_sender,
_recipient,
_destinationCaller,
_minFinalityThreshold,
EMPTY_FINALITY_THRESHOLD_EXECUTED,
_messageBody
);
}
// @notice Returns _message's version field
function _getVersion(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(VERSION_INDEX, 4));
}
// @notice Returns _message's sourceDomain field
function _getSourceDomain(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(SOURCE_DOMAIN_INDEX, 4));
}
// @notice Returns _message's destinationDomain field
function _getDestinationDomain(
bytes29 _message
) internal pure returns (uint32) {
return uint32(_message.indexUint(DESTINATION_DOMAIN_INDEX, 4));
}
// @notice Returns _message's nonce field
function _getNonce(bytes29 _message) internal pure returns (bytes32) {
return _message.index(NONCE_INDEX, 32);
}
// @notice Returns _message's sender field
function _getSender(bytes29 _message) internal pure returns (bytes32) {
return _message.index(SENDER_INDEX, 32);
}
// @notice Returns _message's recipient field
function _getRecipient(bytes29 _message) internal pure returns (bytes32) {
return _message.index(RECIPIENT_INDEX, 32);
}
// @notice Returns _message's destinationCaller field
function _getDestinationCaller(
bytes29 _message
) internal pure returns (bytes32) {
return _message.index(DESTINATION_CALLER_INDEX, 32);
}
// @notice Returns _message's minFinalityThreshold field
function _getMinFinalityThreshold(
bytes29 _message
) internal pure returns (uint32) {
return uint32(_message.indexUint(MIN_FINALITY_THRESHOLD_INDEX, 4));
}
// @notice Returns _message's finalityThresholdExecuted field
function _getFinalityThresholdExecuted(
bytes29 _message
) internal pure returns (uint32) {
return uint32(_message.indexUint(FINALITY_THRESHOLD_EXECUTED_INDEX, 4));
}
// @notice Returns _message's messageBody field
function _getMessageBody(bytes29 _message) internal pure returns (bytes29) {
return
_message.slice(
MESSAGE_BODY_INDEX,
_message.len() - MESSAGE_BODY_INDEX,
0
);
}
/**
* @notice Reverts if message is malformed or too short
* @param _message The message as bytes29
*/
function _validateMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(
_message.len() >= MESSAGE_BODY_INDEX,
"Invalid message: too short"
);
}
}
import {BurnMessageV1} from "./CctpMessageV1.sol";
/**
* @title BurnMessageV2 Library
* @notice Library for formatted V2 BurnMessages used by TokenMessengerV2.
* @dev BurnMessageV2 format:
* Field Bytes Type Index
* version 4 uint32 0
* burnToken 32 bytes32 4
* mintRecipient 32 bytes32 36
* amount 32 uint256 68
* messageSender 32 bytes32 100
* maxFee 32 uint256 132
* feeExecuted 32 uint256 164
* expirationBlock 32 uint256 196
* hookData dynamic bytes 228
* @dev Additions from v1:
* - maxFee
* - feeExecuted
* - expirationBlock
* - hookData
**/
library BurnMessageV2 {
using TypedMemView for bytes;
using TypedMemView for bytes29;
using BurnMessageV1 for bytes29;
// Field indices
uint8 private constant MAX_FEE_INDEX = 132;
uint8 private constant FEE_EXECUTED_INDEX = 164;
uint8 private constant EXPIRATION_BLOCK_INDEX = 196;
uint8 private constant HOOK_DATA_INDEX = 228;
uint256 private constant EMPTY_FEE_EXECUTED = 0;
uint256 private constant EMPTY_EXPIRATION_BLOCK = 0;
/**
* @notice Formats a V2 burn message
* @param _version The message body version
* @param _burnToken The burn token address on the source domain, as bytes32
* @param _mintRecipient The mint recipient address as bytes32
* @param _amount The burn amount
* @param _messageSender The message sender
* @param _maxFee The maximum fee to be paid on destination domain
* @param _hookData Optional hook data for processing on the destination domain
* @return Formatted message bytes.
*/
function _formatMessageForRelay(
uint32 _version,
bytes32 _burnToken,
bytes32 _mintRecipient,
uint256 _amount,
bytes32 _messageSender,
uint256 _maxFee,
bytes memory _hookData
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_version,
_burnToken,
_mintRecipient,
_amount,
_messageSender,
_maxFee,
EMPTY_FEE_EXECUTED,
EMPTY_EXPIRATION_BLOCK,
_hookData
);
}
// @notice Returns _message's version field
function _getVersion(bytes29 _message) internal pure returns (uint32) {
return _message._getVersion();
}
// @notice Returns _message's burnToken field
function _getBurnToken(bytes29 _message) internal pure returns (bytes32) {
return _message._getBurnToken();
}
// @notice Returns _message's mintRecipient field
function _getMintRecipient(
bytes29 _message
) internal pure returns (bytes32) {
return _message._getMintRecipient();
}
// @notice Returns _message's amount field
function _getAmount(bytes29 _message) internal pure returns (uint256) {
return _message._getAmount();
}
// @notice Returns _message's messageSender field
function _getMessageSender(
bytes29 _message
) internal pure returns (bytes32) {
return _message._getMessageSender();
}
// @notice Returns _message's maxFee field
function _getMaxFee(bytes29 _message) internal pure returns (uint256) {
return _message.indexUint(MAX_FEE_INDEX, 32);
}
// @notice Returns _message's feeExecuted field
function _getFeeExecuted(bytes29 _message) internal pure returns (uint256) {
return _message.indexUint(FEE_EXECUTED_INDEX, 32);
}
// @notice Returns _message's expirationBlock field
function _getExpirationBlock(
bytes29 _message
) internal pure returns (uint256) {
return _message.indexUint(EXPIRATION_BLOCK_INDEX, 32);
}
// @notice Returns _message's hookData field
function _getHookData(bytes29 _message) internal pure returns (bytes29) {
return
_message.slice(
HOOK_DATA_INDEX,
_message.len() - HOOK_DATA_INDEX,
0
);
}
/**
* @notice Reverts if burn message is malformed or invalid length
* @param _message The burn message as bytes29
*/
function _validateBurnMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(
_message.len() >= HOOK_DATA_INDEX,
"Invalid burn message: too short"
);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
library TypeCasts {
// alignment preserving cast
function addressToBytes32(address _addr) internal pure returns (bytes32) {
return bytes32(uint256(uint160(_addr)));
}
// alignment preserving cast
function bytes32ToAddress(bytes32 _buf) internal pure returns (address) {
require(
uint256(_buf) <= uint256(type(uint160).max),
"TypeCasts: bytes32ToAddress overflow"
);
return address(uint160(uint256(_buf)));
}
}/*
* Copyright 2024 Circle Internet Group, Inc. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
/**
* @title IMessageHandlerV2
* @notice Handles messages on the destination domain, forwarded from
* an IReceiverV2.
*/
interface IMessageHandlerV2 {
/**
* @notice Handles an incoming finalized message from an IReceiverV2
* @dev Finalized messages have finality threshold values greater than or equal to 2000
* @param sourceDomain The source domain of the message
* @param sender The sender of the message
* @param finalityThresholdExecuted the finality threshold at which the message was attested to
* @param messageBody The raw bytes of the message body
* @return success True, if successful; false, if not.
*/
function handleReceiveFinalizedMessage(
uint32 sourceDomain,
bytes32 sender,
uint32 finalityThresholdExecuted,
bytes calldata messageBody
) external returns (bool);
/**
* @notice Handles an incoming unfinalized message from an IReceiverV2
* @dev Unfinalized messages have finality threshold values less than 2000
* @param sourceDomain The source domain of the message
* @param sender The sender of the message
* @param finalityThresholdExecuted The finality threshold at which the message was attested to
* @param messageBody The raw bytes of the message body
* @return success True, if successful; false, if not.
*/
function handleReceiveUnfinalizedMessage(
uint32 sourceDomain,
bytes32 sender,
uint32 finalityThresholdExecuted,
bytes calldata messageBody
) external returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {ITokenMessenger} from "./ITokenMessenger.sol";
interface ITokenMessengerV2 is ITokenMessenger {
event DepositForBurn(
address indexed burnToken,
uint256 amount,
address indexed depositor,
bytes32 mintRecipient,
uint32 destinationDomain,
bytes32 destinationTokenMessenger,
bytes32 destinationCaller,
uint256 maxFee,
uint32 indexed minFinalityThreshold,
bytes hookData
);
function depositForBurn(
uint256 amount,
uint32 destinationDomain,
bytes32 mintRecipient,
address burnToken,
bytes32 destinationCaller,
uint256 maxFee,
uint32 minFinalityThreshold
) external;
}/*
* Copyright 2024 Circle Internet Group, Inc. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
import {IMessageTransmitter} from "./IMessageTransmitter.sol";
import {IReceiver} from "./IMessageTransmitter.sol";
/**
* @title IReceiverV2
* @notice Receives messages on the destination chain and forwards them to contracts implementing
* IMessageHandlerV2.
*/
interface IReceiverV2 is IReceiver {}
/**
* @title IRelayerV2
* @notice Sends messages from the source domain to the destination domain
*/
interface IRelayerV2 {
/**
* @notice Sends an outgoing message from the source domain.
* @dev Emits a `MessageSent` event with message information.
* WARNING: if the `destinationCaller` does not represent a valid address as bytes32, then it will not be possible
* to broadcast the message on the destination domain. If set to bytes32(0), anyone will be able to broadcast it.
* This is an advanced feature, and using bytes32(0) should be preferred for use cases where a specific destination caller is not required.
* @param destinationDomain Domain of destination chain
* @param recipient Address of message recipient on destination domain as bytes32
* @param destinationCaller Allowed caller on destination domain (see above WARNING).
* @param minFinalityThreshold Minimum finality threshold at which the message must be attested to.
* @param messageBody Content of the message, as raw bytes
*/
function sendMessage(
uint32 destinationDomain,
bytes32 recipient,
bytes32 destinationCaller,
uint32 minFinalityThreshold,
bytes calldata messageBody
) external;
}
/**
* @title IMessageTransmitterV2
* @notice Interface for V2 message transmitters, which both relay and receive messages.
*/
interface IMessageTransmitterV2 is
IRelayerV2,
IReceiverV2,
IMessageTransmitter
{}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
// ============ Internal Imports ============
import {TokenMessage} from "./libs/TokenMessage.sol";
import {TokenRouter} from "./libs/TokenRouter.sol";
import {MovableCollateralRouter} from "./libs/MovableCollateralRouter.sol";
import {LpCollateralRouter} from "./libs/LpCollateralRouter.sol";
import {ITokenBridge, Quote} from "../interfaces/ITokenBridge.sol";
import {ERC20Collateral} from "./libs/TokenCollateral.sol";
import {EnumerableMapExtended} from "../libs/EnumerableMapExtended.sol";
// ============ External Imports ============
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/**
* @title Hyperlane ERC20 Token Collateral that wraps an existing ERC20 with remote transfer functionality.
* @author Abacus Works
*/
contract HypERC20Collateral is LpCollateralRouter {
using SafeERC20 for IERC20;
using ERC20Collateral for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
IERC20 public immutable wrappedToken;
/**
* @notice Constructor
* @param erc20 Address of the token to keep as collateral
*/
constructor(
address erc20,
uint256 _scale,
address _mailbox
) TokenRouter(_scale, _mailbox) {
require(Address.isContract(erc20), "HypERC20Collateral: invalid token");
wrappedToken = IERC20(erc20);
}
function initialize(
address _hook,
address _interchainSecurityModule,
address _owner
) public initializer {
_MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
_LpCollateralRouter_initialize();
}
function token() public view override returns (address) {
return address(wrappedToken);
}
function _addBridge(uint32 domain, ITokenBridge bridge) internal override {
MovableCollateralRouter._addBridge(domain, bridge);
wrappedToken.forceApprove(address(bridge), type(uint256).max);
}
function _removeBridge(
uint32 domain,
ITokenBridge bridge
) internal override {
MovableCollateralRouter._removeBridge(domain, bridge);
uint32[] memory knownDomains = _routers.uint32Keys();
// Iteration is fine as number of enrolled domains is bounded
for (uint256 i = 0; i < knownDomains.length; i++) {
EnumerableSet.AddressSet storage bridges = allowed.bridges[
knownDomains[i]
];
if (bridges.contains(address(bridge))) {
return;
}
}
wrappedToken.forceApprove(address(bridge), 0);
}
/**
* @dev Transfers `_amount` of `wrappedToken` from `msg.sender` to this contract.
* @inheritdoc TokenRouter
*/
function _transferFromSender(uint256 _amount) internal override {
wrappedToken._transferFromSender(_amount);
}
/**
* @dev Transfers `_amount` of `wrappedToken` from this contract to `_recipient`.
* @inheritdoc TokenRouter
*/
function _transferTo(
address _recipient,
uint256 _amount
) internal override {
wrappedToken._transferTo(_recipient, _amount);
}
}/*
* Copyright (c) 2022, Circle Internet Financial Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
// @dev copied from https://github.com/circlefin/evm-cctp-contracts
interface IRelayer {
function sendMessage(
uint32 destinationDomain,
bytes32 recipient,
bytes calldata messageBody
) external returns (uint64);
function sendMessageWithCaller(
uint32 destinationDomain,
bytes32 recipient,
bytes32 destinationCaller,
bytes calldata messageBody
) external returns (uint64);
function replaceMessage(
bytes calldata originalMessage,
bytes calldata originalAttestation,
bytes calldata newMessageBody,
bytes32 newDestinationCaller
) external;
}
interface IReceiver {
function receiveMessage(
bytes calldata message,
bytes calldata signature
) external returns (bool success);
}
interface IMessageTransmitter is IRelayer, IReceiver {
event MessageSent(bytes message);
function usedNonces(
bytes32 sourceAndNonceHash
) external view returns (uint256);
function version() external view returns (uint32);
function localDomain() external view returns (uint32);
function nextAvailableNonce() external view returns (uint64);
function signatureThreshold() external view returns (uint256);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
interface IInterchainSecurityModule {
enum Types {
UNUSED,
ROUTING,
AGGREGATION,
LEGACY_MULTISIG,
MERKLE_ROOT_MULTISIG,
MESSAGE_ID_MULTISIG,
NULL, // used with relayer carrying no metadata
CCIP_READ,
ARB_L2_TO_L1,
WEIGHTED_MERKLE_ROOT_MULTISIG,
WEIGHTED_MESSAGE_ID_MULTISIG,
OP_L2_TO_L1,
POLYMER
}
/**
* @notice Returns an enum that represents the type of security model
* encoded by this ISM.
* @dev Relayers infer how to fetch and format metadata.
*/
function moduleType() external view returns (uint8);
/**
* @notice Defines a security model responsible for verifying interchain
* messages based on the provided metadata.
* @param _metadata Off-chain metadata provided by a relayer, specific to
* the security model encoded by the module (e.g. validator signatures)
* @param _message Hyperlane encoded interchain message
* @return True if the message was verified
*/
function verify(
bytes calldata _metadata,
bytes calldata _message
) external returns (bool);
}
interface ISpecifiesInterchainSecurityModule {
function interchainSecurityModule()
external
view
returns (IInterchainSecurityModule);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
// ============ Internal Imports ============
import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
import {ICcipReadIsm} from "../../interfaces/isms/ICcipReadIsm.sol";
import {PackageVersioned} from "../../PackageVersioned.sol";
// ============ External Imports ============
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
/**
* @title AbstractCcipReadIsm
* @notice An ISM that allows arbitrary payloads to be submitted and verified on chain
* @dev https://eips.ethereum.org/EIPS/eip-3668
* @dev The AbstractCcipReadIsm provided by Hyperlane is left intentionally minimalist as
* the range of applications that could be supported by a CcipReadIsm are so broad. However
* there are few things to note when building a custom CcipReadIsm.
*
*/
abstract contract AbstractCcipReadIsm is
ICcipReadIsm,
OwnableUpgradeable,
PackageVersioned
{
// ============ Constants ============
// solhint-disable-next-line const-name-snakecase
uint8 public constant moduleType =
uint8(IInterchainSecurityModule.Types.CCIP_READ);
string[] internal _urls;
/**
* @notice Emitted when new CCIP-read urls are being set
*/
event UrlsChanged(string[] newUrls);
function setUrls(string[] memory __urls) public onlyOwner {
require(__urls.length > 0, "AbstractCcipReadIsm: urls cannot be empty");
_urls = __urls;
emit UrlsChanged(__urls);
}
function getOffchainVerifyInfo(
bytes calldata _message
) external view override {
revert OffchainLookup({
sender: address(this),
urls: _urls,
callData: _offchainLookupCalldata(_message),
callbackFunction: this.verify.selector,
extraData: _message
});
}
function urls() external view returns (string[] memory) {
return _urls;
}
/*
* @dev This should return the calldata to be used for the offchain lookup.
**/
function _offchainLookupCalldata(
bytes calldata _message
) internal view virtual returns (bytes memory);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ITokenMessenger {
function messageBodyVersion() external returns (uint32);
}
interface ITokenMessengerV1 is ITokenMessenger {
event DepositForBurn(
uint64 indexed nonce,
address indexed burnToken,
uint256 amount,
address indexed depositor,
bytes32 mintRecipient,
uint32 destinationDomain,
bytes32 destinationTokenMessenger,
bytes32 destinationCaller
);
function depositForBurn(
uint256 amount,
uint32 destinationDomain,
bytes32 mintRecipient,
address burnToken
) external returns (uint64 _nonce);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
interface IPostDispatchHook {
enum HookTypes {
UNUSED,
ROUTING,
AGGREGATION,
MERKLE_TREE,
INTERCHAIN_GAS_PAYMASTER,
FALLBACK_ROUTING,
ID_AUTH_ISM,
PAUSABLE,
PROTOCOL_FEE,
DEPRECATED,
RATE_LIMITED,
ARB_L2_TO_L1,
OP_L2_TO_L1,
MAILBOX_DEFAULT_HOOK,
AMOUNT_ROUTING,
CCTP
}
/**
* @notice Returns an enum that represents the type of hook
*/
function hookType() external view returns (uint8);
/**
* @notice Returns whether the hook supports metadata
* @param metadata metadata
* @return Whether the hook supports metadata
*/
function supportsMetadata(
bytes calldata metadata
) external view returns (bool);
/**
* @notice Post action after a message is dispatched via the Mailbox
* @param metadata The metadata required for the hook
* @param message The message passed from the Mailbox.dispatch() call
*/
function postDispatch(
bytes calldata metadata,
bytes calldata message
) external payable;
/**
* @notice Compute the payment required by the postDispatch call
* @param metadata The metadata required for the hook
* @param message The message passed from the Mailbox.dispatch() call
* @return Quoted payment for the postDispatch call
*/
function quoteDispatch(
bytes calldata metadata,
bytes calldata message
) external view returns (uint256);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
/**
* Format of metadata:
*
* [0:2] variant
* [2:34] msg.value
* [34:66] Gas limit for message (IGP)
* [66:86] Refund address for message (IGP)
* [86:] Custom metadata
*/
library StandardHookMetadata {
struct Metadata {
uint16 variant;
uint256 msgValue;
uint256 gasLimit;
address refundAddress;
}
uint8 private constant VARIANT_OFFSET = 0;
uint8 private constant MSG_VALUE_OFFSET = 2;
uint8 private constant GAS_LIMIT_OFFSET = 34;
uint8 private constant REFUND_ADDRESS_OFFSET = 66;
uint256 private constant MIN_METADATA_LENGTH = 86;
uint16 public constant VARIANT = 1;
/**
* @notice Returns the variant of the metadata.
* @param _metadata ABI encoded standard hook metadata.
* @return variant of the metadata as uint8.
*/
function variant(bytes calldata _metadata) internal pure returns (uint16) {
if (_metadata.length < VARIANT_OFFSET + 2) return 0;
return uint16(bytes2(_metadata[VARIANT_OFFSET:VARIANT_OFFSET + 2]));
}
/**
* @notice Returns the specified value for the message.
* @param _metadata ABI encoded standard hook metadata.
* @param _default Default fallback value.
* @return Value for the message as uint256.
*/
function msgValue(
bytes calldata _metadata,
uint256 _default
) internal pure returns (uint256) {
if (_metadata.length < MSG_VALUE_OFFSET + 32) return _default;
return
uint256(bytes32(_metadata[MSG_VALUE_OFFSET:MSG_VALUE_OFFSET + 32]));
}
/**
* @notice Returns the specified gas limit for the message.
* @param _metadata ABI encoded standard hook metadata.
* @param _default Default fallback gas limit.
* @return Gas limit for the message as uint256.
*/
function gasLimit(
bytes calldata _metadata,
uint256 _default
) internal pure returns (uint256) {
if (_metadata.length < GAS_LIMIT_OFFSET + 32) return _default;
return
uint256(bytes32(_metadata[GAS_LIMIT_OFFSET:GAS_LIMIT_OFFSET + 32]));
}
function gasLimit(
bytes memory _metadata
) internal pure returns (uint256 _gasLimit) {
if (_metadata.length < GAS_LIMIT_OFFSET + 32) return 50_000;
assembly {
_gasLimit := mload(add(_metadata, add(0x20, GAS_LIMIT_OFFSET)))
}
}
/**
* @notice Returns the specified refund address for the message.
* @param _metadata ABI encoded standard hook metadata.
* @param _default Default fallback refund address.
* @return Refund address for the message as address.
*/
function refundAddress(
bytes calldata _metadata,
address _default
) internal pure returns (address) {
if (_metadata.length < REFUND_ADDRESS_OFFSET + 20) return _default;
return
address(
bytes20(
_metadata[REFUND_ADDRESS_OFFSET:REFUND_ADDRESS_OFFSET + 20]
)
);
}
/**
* @notice Returns any custom metadata.
* @param _metadata ABI encoded standard hook metadata.
* @return Custom metadata.
*/
function getCustomMetadata(
bytes calldata _metadata
) internal pure returns (bytes calldata) {
if (_metadata.length < MIN_METADATA_LENGTH) return _metadata[0:0];
return _metadata[MIN_METADATA_LENGTH:];
}
/**
* @notice Formats the specified gas limit and refund address into standard hook metadata.
* @param _msgValue msg.value for the message.
* @param _gasLimit Gas limit for the message.
* @param _refundAddress Refund address for the message.
* @return ABI encoded standard hook metadata.
*/
function format(
uint256 _msgValue,
uint256 _gasLimit,
address _refundAddress
) internal pure returns (bytes memory) {
return abi.encodePacked(VARIANT, _msgValue, _gasLimit, _refundAddress);
}
/**
/**
* @notice Formats the specified gas limit and refund address into standard hook metadata.
* @param _msgValue msg.value for the message.
* @param _gasLimit Gas limit for the message.
* @param _refundAddress Refund address for the message.
* @param _customMetadata Additional metadata to include in the standard hook metadata.
* @return ABI encoded standard hook metadata.
*/
function formatMetadata(
uint256 _msgValue,
uint256 _gasLimit,
address _refundAddress,
bytes memory _customMetadata
) internal pure returns (bytes memory) {
return
abi.encodePacked(
VARIANT,
_msgValue,
_gasLimit,
_refundAddress,
_customMetadata
);
}
/**
* @notice Formats the specified gas limit and refund address into standard hook metadata.
* @param _msgValue msg.value for the message.
* @return ABI encoded standard hook metadata.
*/
function overrideMsgValue(
uint256 _msgValue
) internal view returns (bytes memory) {
return formatMetadata(_msgValue, uint256(0), msg.sender, "");
}
/**
* @notice Formats the specified gas limit and refund address into standard hook metadata.
* @param _gasLimit Gas limit for the message.
* @return ABI encoded standard hook metadata.
*/
function overrideGasLimit(
uint256 _gasLimit
) internal view returns (bytes memory) {
return formatMetadata(uint256(0), _gasLimit, msg.sender, "");
}
/**
* @notice Formats the specified refund address into standard hook metadata.
* @param _refundAddress Refund address for the message.
* @return ABI encoded standard hook metadata.
*/
function overrideRefundAddress(
address _refundAddress
) internal pure returns (bytes memory) {
return formatMetadata(uint256(0), uint256(0), _refundAddress, "");
}
function getRefundAddress(
bytes memory _metadata,
address _default
) internal pure returns (address) {
if (_metadata.length < REFUND_ADDRESS_OFFSET + 20) return _default;
address result;
assembly {
let data_start_ptr := add(_metadata, 32) // Skip length prefix of _metadata
let mload_ptr := add(data_start_ptr, sub(REFUND_ADDRESS_OFFSET, 12))
result := mload(mload_ptr) // Loads 32 bytes; address takes lower 20 bytes.
}
return result;
}
}/*
* Copyright (c) 2022, Circle Internet Financial Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
// copied from https://github.com/circlefin/evm-cctp-contracts/blob/6e7513cdb2bee6bb0cddf331fe972600fc5017c9/src/interfaces/IMessageHandler.sol
/**
* @title IMessageHandler
* @notice Handles messages on destination domain forwarded from
* an IReceiver
*/
interface IMessageHandler {
/**
* @notice handles an incoming message from a Receiver
* @param sourceDomain the source domain of the message
* @param sender the sender of the message
* @param messageBody The message raw bytes
* @return success bool, true if successful
*/
function handleReceiveMessage(
uint32 sourceDomain,
bytes32 sender,
bytes calldata messageBody
) external returns (bool);
}// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.0;
import {ITokenBridge, Quote} from "../../interfaces/ITokenBridge.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {TokenRouter} from "./TokenRouter.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Router} from "../../client/Router.sol";
import {Quotes} from "./Quotes.sol";
struct MovableCollateralRouterStorage {
mapping(uint32 routerDomain => bytes32 recipient) recipient;
mapping(uint32 routerDomain => EnumerableSet.AddressSet bridges) bridges;
EnumerableSet.AddressSet rebalancers;
}
abstract contract MovableCollateralRouter is TokenRouter {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using Quotes for Quote[];
MovableCollateralRouterStorage internal allowed;
event CollateralMoved(
uint32 indexed domain,
bytes32 recipient,
uint256 amount,
address indexed rebalancer
);
modifier onlyRebalancer() {
require(
allowed.rebalancers.contains(_msgSender()),
"MCR: Only Rebalancer"
);
_;
}
modifier onlyAllowedBridge(uint32 domain, ITokenBridge bridge) {
EnumerableSet.AddressSet storage bridges = allowed.bridges[domain];
require(bridges.contains(address(bridge)), "MCR: Not allowed bridge");
_;
}
/// @notice Set of addresses that are allowed to rebalance.
function allowedRebalancers() external view returns (address[] memory) {
return allowed.rebalancers.values();
}
/// @notice Mapping of domain to allowed rebalance recipient.
/// @dev Keys constrained to a subset of Router.domains()
function allowedRecipient(uint32 domain) external view returns (bytes32) {
return allowed.recipient[domain];
}
/// @notice Mapping of domain to allowed rebalance bridges.
/// @dev Keys constrained to a subset of Router.domains()
function allowedBridges(
uint32 domain
) external view returns (address[] memory) {
return allowed.bridges[domain].values();
}
function setRecipient(uint32 domain, bytes32 recipient) external onlyOwner {
// constrain to a subset of Router.domains()
_mustHaveRemoteRouter(domain);
allowed.recipient[domain] = recipient;
}
function removeRecipient(uint32 domain) external onlyOwner {
delete allowed.recipient[domain];
}
function addBridge(uint32 domain, ITokenBridge bridge) external onlyOwner {
// constrain to a subset of Router.domains()
_mustHaveRemoteRouter(domain);
_addBridge(domain, bridge);
}
function _addBridge(uint32 domain, ITokenBridge bridge) internal virtual {
allowed.bridges[domain].add(address(bridge));
}
function removeBridge(
uint32 domain,
ITokenBridge bridge
) external onlyOwner {
_removeBridge(domain, bridge);
}
function _removeBridge(
uint32 domain,
ITokenBridge bridge
) internal virtual {
allowed.bridges[domain].remove(address(bridge));
}
/**
* @notice Approves the token for the bridge.
* @param token The token to approve.
* @param bridge The bridge to approve the token for.
* @dev We need this to support bridges that charge fees in ERC20 tokens.
*/
function approveTokenForBridge(
IERC20 token,
ITokenBridge bridge
) external onlyOwner {
token.safeApprove(address(bridge), type(uint256).max);
}
function addRebalancer(address rebalancer) external onlyOwner {
allowed.rebalancers.add(rebalancer);
}
function removeRebalancer(address rebalancer) external onlyOwner {
allowed.rebalancers.remove(rebalancer);
}
/**
* @notice Rebalances the collateral between router domains.
* @param domain The domain to rebalance to.
* @param collateralAmount The amount of collateral to rebalance.
* @param bridge The bridge to use for the rebalance.
* @dev The caller must be an allowed rebalancer and the bridge must be an allowed bridge for the domain.
* @dev The recipient is the enrolled router if no recipient is set for the domain.
*/
function rebalance(
uint32 domain,
uint256 collateralAmount,
ITokenBridge bridge
) external payable onlyRebalancer onlyAllowedBridge(domain, bridge) {
bytes32 recipient = _recipient(domain);
Quote[] memory quotes = bridge.quoteTransferRemote(
domain,
recipient,
collateralAmount
);
// charge the rebalancer any bridging fees denominated in the collateral
// token to avoid undercollateralization
uint256 collateralFees = quotes.extract(token());
if (collateralFees > collateralAmount) {
_transferFromSender(collateralFees - collateralAmount);
}
// need to handle native quote separately from collateral quote because
// token() may be address(0), in which case we need to use address(this).balance
// to move native collateral tokens across chains
uint256 nativeFees = quotes.extract(address(0));
if (nativeFees > address(this).balance) {
revert("Rebalance native fee exceeds balance");
}
bridge.transferRemote{value: nativeFees}(
domain,
recipient,
collateralAmount
);
emit CollateralMoved(domain, recipient, collateralAmount, msg.sender);
}
function _recipient(
uint32 domain
) internal view returns (bytes32 recipient) {
recipient = allowed.recipient[domain];
if (recipient == bytes32(0)) {
recipient = _mustHaveRemoteRouter(domain);
}
}
/// @dev This function in `EnumerableSet` was introduced in OpenZeppelin v5. We are using 4.9
/// See https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0-rc.0/contracts/utils/structs/EnumerableSet.sol#L126
function _clear(EnumerableSet.Set storage set) private {
uint256 len = set._values.length;
for (uint256 i = 0; i < len; ++i) {
delete set._indexes[set._values[i]];
}
_unsafeSetLength(set._values, 0);
}
/// @dev A helper for `_clear`. See https://github.com/OpenZeppelin/openzeppelin-contracts/blob/39f5a0284e7eb539354e44b76fcbb69033b22b56/contracts/utils/Arrays.sol#L466
function _unsafeSetLength(bytes32[] storage array, uint256 len) internal {
assembly ("memory-safe") {
sstore(array.slot, len)
}
}
/// @dev Constrains keys of rebalance mappings to Router.domains()
function _unenrollRemoteRouter(uint32 domain) internal override {
delete allowed.recipient[domain];
_clear(allowed.bridges[domain]._inner);
Router._unenrollRemoteRouter(domain);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
// ============ Internal Imports ============
import {StandardHookMetadata} from "./StandardHookMetadata.sol";
import {IPostDispatchHook} from "../../interfaces/hooks/IPostDispatchHook.sol";
import {PackageVersioned} from "../../PackageVersioned.sol";
import {Message} from "../../libs/Message.sol";
/**
* @title AbstractPostDispatch
* @notice Abstract post dispatch hook supporting the current global hook metadata variant.
*/
abstract contract AbstractPostDispatchHook is
IPostDispatchHook,
PackageVersioned
{
using StandardHookMetadata for bytes;
using Message for bytes;
using Address for address payable;
// ============ External functions ============
/// @inheritdoc IPostDispatchHook
function supportsMetadata(
bytes calldata metadata
) public pure virtual returns (bool) {
return
metadata.length == 0 ||
metadata.variant() == StandardHookMetadata.VARIANT;
}
function _refund(
bytes calldata metadata,
bytes calldata message,
uint256 amount
) internal {
if (amount == 0) {
return;
}
address refundAddress = metadata.refundAddress(message.senderAddress());
require(
refundAddress != address(0),
"AbstractPostDispatchHook: no refund address"
);
payable(refundAddress).sendValue(amount);
}
/// @inheritdoc IPostDispatchHook
function postDispatch(
bytes calldata metadata,
bytes calldata message
) external payable override {
require(
supportsMetadata(metadata),
"AbstractPostDispatchHook: invalid metadata variant"
);
_postDispatch(metadata, message);
}
/// @inheritdoc IPostDispatchHook
function quoteDispatch(
bytes calldata metadata,
bytes calldata message
) public view override returns (uint256) {
require(
supportsMetadata(metadata),
"AbstractPostDispatchHook: invalid metadata variant"
);
return _quoteDispatch(metadata, message);
}
// ============ Internal functions ============
/**
* @notice Post dispatch hook implementation.
* @param metadata The metadata of the message being dispatched.
* @param message The message being dispatched.
*/
function _postDispatch(
bytes calldata metadata,
bytes calldata message
) internal virtual;
/**
* @notice Quote dispatch hook implementation.
* @param metadata The metadata of the message being dispatched.
* @param message The message being dispatched.
* @return The quote for the dispatch.
*/
function _quoteDispatch(
bytes calldata metadata,
bytes calldata message
) internal view virtual returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
* Revert on invalid signature.
*/
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
// ============ Internal Imports ============
import {Router} from "./Router.sol";
import {StandardHookMetadata} from "../hooks/libs/StandardHookMetadata.sol";
abstract contract GasRouter is Router {
event GasSet(uint32 domain, uint256 gas);
// ============ Mutable Storage ============
mapping(uint32 destinationDomain => uint256 gasLimit) public destinationGas;
struct GasRouterConfig {
uint32 domain;
uint256 gas;
}
constructor(address _mailbox) Router(_mailbox) {}
/**
* @notice Sets the gas amount dispatched for each configured domain.
* @param gasConfigs The array of GasRouterConfig structs
*/
function setDestinationGas(
GasRouterConfig[] calldata gasConfigs
) external onlyOwner {
for (uint256 i = 0; i < gasConfigs.length; i += 1) {
_setDestinationGas(gasConfigs[i].domain, gasConfigs[i].gas);
}
}
/**
* @notice Sets the gas amount dispatched for each configured domain.
* @param domain The destination domain ID
* @param gas The gas limit
*/
function setDestinationGas(uint32 domain, uint256 gas) external onlyOwner {
_setDestinationGas(domain, gas);
}
/**
* @notice Returns the gas payment required to dispatch a message to the given domain's router.
* @param _destinationDomain The domain of the router.
* @return _gasPayment Payment computed by the registered InterchainGasPaymaster.
*/
function quoteGasPayment(
uint32 _destinationDomain
) public view virtual returns (uint256) {
return
_Router_quoteDispatch(
_destinationDomain,
"",
_GasRouter_hookMetadata(_destinationDomain),
address(hook)
);
}
function _GasRouter_hookMetadata(
uint32 _destination
) internal view returns (bytes memory) {
return
StandardHookMetadata.overrideGasLimit(destinationGas[_destination]);
}
function _setDestinationGas(uint32 domain, uint256 gas) internal {
destinationGas[domain] = gas;
emit GasSet(domain, gas);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
struct Quote {
address token; // address(0) for the native token
uint256 amount;
}
interface ITokenFee {
/**
* @notice Provide the value transfer quote
* @param _destination The destination domain of the message
* @param _recipient The message recipient address on `destination`
* @param _amount The amount to send to the recipient
* @return quotes Indicate how much of each token to approve and/or send.
* @dev Good practice is to use the first entry of the quotes for the native currency (i.e. ETH).
* @dev Good practice is to use the last entry of the quotes for the token to be transferred.
* @dev There should not be duplicate `token` addresses in the returned quotes.
*/
function quoteTransferRemote(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) external view returns (Quote[] memory quotes);
}
interface ITokenBridge is ITokenFee {
/**
* @notice Transfer value to another domain
* @param _destination The destination domain of the message
* @param _recipient The message recipient address on `destination`
* @param _amount The amount to send to the recipient
* @return messageId The identifier of the dispatched message.
*/
function transferRemote(
uint32 _destination,
bytes32 _recipient,
uint256 _amount
) external payable returns (bytes32);
}// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.0;
import {Quote} from "../../interfaces/ITokenBridge.sol";
library Quotes {
function extract(
Quote[] memory quotes,
address token
) internal pure returns (uint256 sum) {
sum = 0;
for (uint256 i = 0; i < quotes.length; i++) {
if (quotes[i].token == token) {
sum += quotes[i].amount;
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
* _Available since v4.9 for `string`, `bytes`._
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}/*
* Copyright (c) 2022, Circle Internet Financial Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity >=0.8.0;
import {TypedMemView} from "./TypedMemView.sol";
// @dev CCTP Message version 1
// @dev copied from https://github.com/circlefin/evm-cctp-contracts/blob/release-2025-03-11T143015/src/messages/Message.sol
/**
* @title Message Library
* @notice Library for formatted messages used by Relayer and Receiver.
*
* @dev The message body is dynamically-sized to support custom message body
* formats. Other fields must be fixed-size to avoid hash collisions.
* Each other input value has an explicit type to guarantee fixed-size.
* Padding: uintNN fields are left-padded, and bytesNN fields are right-padded.
*
* Field Bytes Type Index
* version 4 uint32 0
* sourceDomain 4 uint32 4
* destinationDomain 4 uint32 8
* nonce 8 uint64 12
* sender 32 bytes32 20
* recipient 32 bytes32 52
* destinationCaller 32 bytes32 84
* messageBody dynamic bytes 116
*
**/
library CctpMessageV1 {
using TypedMemView for bytes;
using TypedMemView for bytes29;
// Indices of each field in message
uint8 private constant VERSION_INDEX = 0;
uint8 private constant SOURCE_DOMAIN_INDEX = 4;
uint8 private constant DESTINATION_DOMAIN_INDEX = 8;
uint8 private constant NONCE_INDEX = 12;
uint8 private constant SENDER_INDEX = 20;
uint8 private constant RECIPIENT_INDEX = 52;
uint8 private constant DESTINATION_CALLER_INDEX = 84;
uint8 private constant MESSAGE_BODY_INDEX = 116;
/**
* @notice Returns formatted (packed) message with provided fields
* @param _msgVersion the version of the message format
* @param _msgSourceDomain Domain of home chain
* @param _msgDestinationDomain Domain of destination chain
* @param _msgNonce Destination-specific nonce
* @param _msgSender Address of sender on source chain as bytes32
* @param _msgRecipient Address of recipient on destination chain as bytes32
* @param _msgDestinationCaller Address of caller on destination chain as bytes32
* @param _msgRawBody Raw bytes of message body
* @return Formatted message
**/
function _formatMessage(
uint32 _msgVersion,
uint32 _msgSourceDomain,
uint32 _msgDestinationDomain,
uint64 _msgNonce,
bytes32 _msgSender,
bytes32 _msgRecipient,
bytes32 _msgDestinationCaller,
bytes memory _msgRawBody
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_msgVersion,
_msgSourceDomain,
_msgDestinationDomain,
_msgNonce,
_msgSender,
_msgRecipient,
_msgDestinationCaller,
_msgRawBody
);
}
// @notice Returns _message's version field
function _version(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(VERSION_INDEX, 4));
}
// @notice Returns _message's sourceDomain field
function _sourceDomain(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(SOURCE_DOMAIN_INDEX, 4));
}
// @notice Returns _message's destinationDomain field
function _destinationDomain(
bytes29 _message
) internal pure returns (uint32) {
return uint32(_message.indexUint(DESTINATION_DOMAIN_INDEX, 4));
}
// @notice Returns _message's nonce field
function _nonce(bytes29 _message) internal pure returns (uint64) {
return uint64(_message.indexUint(NONCE_INDEX, 8));
}
// @notice Returns _message's sender field
function _sender(bytes29 _message) internal pure returns (bytes32) {
return _message.index(SENDER_INDEX, 32);
}
// @notice Returns _message's recipient field
function _recipient(bytes29 _message) internal pure returns (bytes32) {
return _message.index(RECIPIENT_INDEX, 32);
}
// @notice Returns _message's destinationCaller field
function _destinationCaller(
bytes29 _message
) internal pure returns (bytes32) {
return _message.index(DESTINATION_CALLER_INDEX, 32);
}
// @notice Returns _message's messageBody field
function _messageBody(bytes29 _message) internal pure returns (bytes29) {
return
_message.slice(
MESSAGE_BODY_INDEX,
_message.len() - MESSAGE_BODY_INDEX,
0
);
}
/**
* @notice converts address to bytes32 (alignment preserving cast.)
* @param addr the address to convert to bytes32
*/
function addressToBytes32(address addr) external pure returns (bytes32) {
return bytes32(uint256(uint160(addr)));
}
/**
* @notice converts bytes32 to address (alignment preserving cast.)
* @dev Warning: it is possible to have different input values _buf map to the same address.
* For use cases where this is not acceptable, validate that the first 12 bytes of _buf are zero-padding.
* @param _buf the bytes32 to convert to address
*/
function bytes32ToAddress(bytes32 _buf) public pure returns (address) {
return address(uint160(uint256(_buf)));
}
/**
* @notice Reverts if message is malformed or incorrect length
* @param _message The message as bytes29
*/
function _validateMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(
_message.len() >= MESSAGE_BODY_INDEX,
"Invalid message: too short"
);
}
}
// @dev copied from https://raw.githubusercontent.com/circlefin/evm-cctp-contracts/refs/tags/release-2025-03-11T143015/src/messages/BurnMessage.sol
/**
* @title BurnMessage Library
* @notice Library for formatted BurnMessages used by TokenMessenger.
* @dev BurnMessage format:
* Field Bytes Type Index
* version 4 uint32 0
* burnToken 32 bytes32 4
* mintRecipient 32 bytes32 36
* amount 32 uint256 68
* messageSender 32 bytes32 100
**/
library BurnMessageV1 {
using TypedMemView for bytes;
using TypedMemView for bytes29;
uint8 private constant VERSION_INDEX = 0;
uint8 private constant VERSION_LEN = 4;
uint8 private constant BURN_TOKEN_INDEX = 4;
uint8 private constant BURN_TOKEN_LEN = 32;
uint8 private constant MINT_RECIPIENT_INDEX = 36;
uint8 private constant MINT_RECIPIENT_LEN = 32;
uint8 private constant AMOUNT_INDEX = 68;
uint8 private constant AMOUNT_LEN = 32;
uint8 private constant MSG_SENDER_INDEX = 100;
uint8 private constant MSG_SENDER_LEN = 32;
// 4 byte version + 32 bytes burnToken + 32 bytes mintRecipient + 32 bytes amount + 32 bytes messageSender
uint8 private constant BURN_MESSAGE_LEN = 132;
/**
* @notice Formats Burn message
* @param _version The message body version
* @param _burnToken The burn token address on source domain as bytes32
* @param _mintRecipient The mint recipient address as bytes32
* @param _amount The burn amount
* @param _messageSender The message sender
* @return Burn formatted message.
*/
function _formatMessage(
uint32 _version,
bytes32 _burnToken,
bytes32 _mintRecipient,
uint256 _amount,
bytes32 _messageSender
) internal pure returns (bytes memory) {
return
abi.encodePacked(
_version,
_burnToken,
_mintRecipient,
_amount,
_messageSender
);
}
/**
* @notice Retrieves the burnToken from a DepositForBurn BurnMessage
* @param _message The message
* @return sourceToken address as bytes32
*/
function _getMessageSender(
bytes29 _message
) internal pure returns (bytes32) {
return _message.index(MSG_SENDER_INDEX, MSG_SENDER_LEN);
}
/**
* @notice Retrieves the burnToken from a DepositForBurn BurnMessage
* @param _message The message
* @return sourceToken address as bytes32
*/
function _getBurnToken(bytes29 _message) internal pure returns (bytes32) {
return _message.index(BURN_TOKEN_INDEX, BURN_TOKEN_LEN);
}
/**
* @notice Retrieves the mintRecipient from a BurnMessage
* @param _message The message
* @return mintRecipient
*/
function _getMintRecipient(
bytes29 _message
) internal pure returns (bytes32) {
return _message.index(MINT_RECIPIENT_INDEX, MINT_RECIPIENT_LEN);
}
/**
* @notice Retrieves the amount from a BurnMessage
* @param _message The message
* @return amount
*/
function _getAmount(bytes29 _message) internal pure returns (uint256) {
return _message.indexUint(AMOUNT_INDEX, AMOUNT_LEN);
}
/**
* @notice Retrieves the version from a Burn message
* @param _message The message
* @return version
*/
function _getVersion(bytes29 _message) internal pure returns (uint32) {
return uint32(_message.indexUint(VERSION_INDEX, VERSION_LEN));
}
/**
* @notice Reverts if burn message is malformed or invalid length
* @param _message The burn message as bytes29
*/
function _validateBurnMessageFormat(bytes29 _message) internal pure {
require(_message.isValid(), "Malformed message");
require(_message.len() == BURN_MESSAGE_LEN, "Invalid message length");
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
// ============ Internal Imports ============
import {MovableCollateralRouter, MovableCollateralRouterStorage} from "./MovableCollateralRouter.sol";
// ============ External Imports ============
import {ERC4626Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC4626Upgradeable.sol";
import {IERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
struct LpCollateralRouterStorage {
// MovableCollateralRouter layout
MovableCollateralRouterStorage __MOVABLE_COLLATERAL_GAP;
// ERC4626 layout
// - (ERC20 layout)
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
// @openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol:376
uint256[45] __ERC20_GAP;
// - (ERC4626 layout)
address _asset;
uint8 _underlyingDecimals;
// @openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC4626Upgradeable.sol:267
uint256[49] __ERC4626_GAP;
// user defined fields
uint256 lpAssets;
}
abstract contract LpCollateralRouter is
MovableCollateralRouter,
ERC4626Upgradeable
{
uint256 private lpAssets;
event Donation(address sender, uint256 amount);
function _LpCollateralRouter_initialize() internal onlyInitializing {
__ERC4626_init(IERC20Upgradeable(token()));
}
function totalAssets() public view override returns (uint256) {
return lpAssets;
}
function asset() public view override returns (address) {
return token();
}
// modeled after ERC4626Upgradeable._deposit
function _deposit(
address caller,
address receiver,
uint256 assets,
uint256 shares
) internal override {
// checks
_transferFromSender(assets);
// effects
lpAssets += assets;
// interactions
_mint(receiver, shares);
emit Deposit(caller, receiver, assets, shares);
}
// modeled after ERC4626Upgradeable._withdraw
function _withdraw(
address caller,
address receiver,
address owner,
uint256 assets,
uint256 shares
) internal override {
// checks
if (caller != owner) {
_spendAllowance(owner, caller, shares);
}
_burn(owner, shares);
// effects
lpAssets -= assets;
// interactions
_transferTo(receiver, assets);
emit Withdraw(caller, receiver, owner, assets, shares);
}
// can be used to distribute rewards to LPs pro rata
function donate(uint256 amount) public payable {
// checks
_transferFromSender(amount);
// effects
lpAssets += amount;
emit Donation(msg.sender, amount);
}
}// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.8.0;
import {IWETH} from "../interfaces/IWETH.sol";
// ============ External Imports ============
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/**
* @title Handles deposits and withdrawals of native token collateral.
*/
library NativeCollateral {
function _transferFromSender(uint256 _amount) internal {
require(msg.value >= _amount, "Native: amount exceeds msg.value");
}
function _transferTo(address _recipient, uint256 _amount) internal {
Address.sendValue(payable(_recipient), _amount);
}
}
/**
* @title Handles deposits and withdrawals of WETH collateral.
* @dev TokenRouters must have `token() == address(0)` to use this library.
*/
library WETHCollateral {
function _transferFromSender(IWETH token, uint256 _amount) internal {
NativeCollateral._transferFromSender(_amount);
token.deposit{value: _amount}();
}
function _transferTo(
IWETH token,
address _recipient,
uint256 _amount
) internal {
token.withdraw(_amount);
NativeCollateral._transferTo(_recipient, _amount);
}
}
/**
* @title Handles deposits and withdrawals of ERC20 collateral.
*/
library ERC20Collateral {
using SafeERC20 for IERC20;
function _transferFromSender(IERC20 token, uint256 _amount) internal {
token.safeTransferFrom(msg.sender, address(this), _amount);
}
function _transferTo(
IERC20 token,
address _recipient,
uint256 _amount
) internal {
token.safeTransfer(_recipient, _amount);
}
}
/**
* @title Handles deposits and withdrawals of ERC721 collateral.
*/
library ERC721Collateral {
function _transferFromSender(IERC721 token, uint256 _tokenId) internal {
// safeTransferFrom not used here because recipient is this contract
token.transferFrom(msg.sender, address(this), _tokenId);
}
function _transferTo(
IERC721 token,
address _recipient,
uint256 _tokenId
) internal {
token.safeTransferFrom(address(this), _recipient, _tokenId);
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
// ============ External Imports ============
import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
// extends EnumerableMap with uint256 => bytes32 type
// modelled after https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.8.0/contracts/utils/structs/EnumerableMap.sol
library EnumerableMapExtended {
using EnumerableMap for EnumerableMap.Bytes32ToBytes32Map;
using EnumerableSet for EnumerableSet.Bytes32Set;
struct UintToBytes32Map {
EnumerableMap.Bytes32ToBytes32Map _inner;
}
// ============ Library Functions ============
function keys(
UintToBytes32Map storage map
) internal view returns (uint256[] memory _keys) {
uint256 _length = map._inner.length();
_keys = new uint256[](_length);
for (uint256 i = 0; i < _length; i++) {
_keys[i] = uint256(map._inner._keys.at(i));
}
}
function uint32Keys(
UintToBytes32Map storage map
) internal view returns (uint32[] memory _keys) {
uint256[] memory uint256keys = keys(map);
_keys = new uint32[](uint256keys.length);
for (uint256 i = 0; i < uint256keys.length; i++) {
_keys[i] = uint32(uint256keys[i]);
}
}
function set(
UintToBytes32Map storage map,
uint256 key,
bytes32 value
) internal {
map._inner.set(bytes32(key), value);
}
function get(
UintToBytes32Map storage map,
uint256 key
) internal view returns (bytes32) {
return map._inner.get(bytes32(key));
}
function tryGet(
UintToBytes32Map storage map,
uint256 key
) internal view returns (bool, bytes32) {
return map._inner.tryGet(bytes32(key));
}
function remove(
UintToBytes32Map storage map,
uint256 key
) internal returns (bool) {
return map._inner.remove(bytes32(key));
}
function contains(
UintToBytes32Map storage map,
uint256 key
) internal view returns (bool) {
return map._inner.contains(bytes32(key));
}
function length(
UintToBytes32Map storage map
) internal view returns (uint256) {
return map._inner.length();
}
function at(
UintToBytes32Map storage map,
uint256 index
) internal view returns (uint256, bytes32) {
(bytes32 key, bytes32 value) = map._inner.at(index);
return (uint256(key), value);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
import {IInterchainSecurityModule} from "../IInterchainSecurityModule.sol";
interface ICcipReadIsm is IInterchainSecurityModule {
/// @dev https://eips.ethereum.org/EIPS/eip-3668
/// @param sender the address of the contract making the call, usually address(this)
/// @param urls the URLs to query for offchain data
/// @param callData context needed for offchain service to service request
/// @param callbackFunction function selector to call with offchain information
/// @param extraData additional passthrough information to call callbackFunction with
error OffchainLookup(
address sender,
string[] urls,
bytes callData,
bytes4 callbackFunction,
bytes extraData
);
/**
* @notice Reverts with the data needed to query information offchain
* and be submitted via the origin mailbox
* @dev See https://eips.ethereum.org/EIPS/eip-3668 for more information
* @param _message data that will help construct the offchain query
*/
function getOffchainVerifyInfo(bytes calldata _message) external view;
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
/**
* @title PackageVersioned
* @notice Package version getter for contracts
**/
abstract contract PackageVersioned {
// GENERATED CODE - DO NOT EDIT
string public constant PACKAGE_VERSION = "10.0.4";
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev 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.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
// ============ Internal Imports ============
import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
import {MailboxClient} from "./MailboxClient.sol";
import {EnumerableMapExtended} from "../libs/EnumerableMapExtended.sol";
// ============ External Imports ============
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
abstract contract Router is MailboxClient, IMessageRecipient {
using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
using Strings for uint32;
// ============ Mutable Storage ============
/// @dev Mapping of domain => router. For a given domain we have one router we send/receive messages from.
EnumerableMapExtended.UintToBytes32Map internal _routers;
uint256[48] private __GAP; // gap for upgrade safety
constructor(address _mailbox) MailboxClient(_mailbox) {}
// ============ External functions ============
function domains() external view returns (uint32[] memory) {
return _routers.uint32Keys();
}
/**
* @notice Returns the address of the Router contract for the given domain
* @param _domain The remote domain ID.
* @dev Returns 0 address if no router is enrolled for the given domain
* @return router The address of the Router contract for the given domain
*/
function routers(uint32 _domain) public view virtual returns (bytes32) {
(, bytes32 _router) = _routers.tryGet(_domain);
return _router;
}
/**
* @notice Unregister the domain
* @param _domain The domain of the remote Application Router
*/
function unenrollRemoteRouter(uint32 _domain) external virtual onlyOwner {
_unenrollRemoteRouter(_domain);
}
/**
* @notice Register the address of a Router contract for the same Application on a remote chain
* @param _domain The domain of the remote Application Router
* @param _router The address of the remote Application Router
*/
function enrollRemoteRouter(
uint32 _domain,
bytes32 _router
) external virtual onlyOwner {
_enrollRemoteRouter(_domain, _router);
}
/**
* @notice Batch version of `enrollRemoteRouter`
* @param _domains The domains of the remote Application Routers
* @param _addresses The addresses of the remote Application Routers
*/
function enrollRemoteRouters(
uint32[] calldata _domains,
bytes32[] calldata _addresses
) external virtual onlyOwner {
require(_domains.length == _addresses.length, "!length");
uint256 length = _domains.length;
for (uint256 i = 0; i < length; i += 1) {
_enrollRemoteRouter(_domains[i], _addresses[i]);
}
}
/**
* @notice Batch version of `unenrollRemoteRouter`
* @param _domains The domains of the remote Application Routers
*/
function unenrollRemoteRouters(
uint32[] calldata _domains
) external virtual onlyOwner {
uint256 length = _domains.length;
for (uint256 i = 0; i < length; i += 1) {
_unenrollRemoteRouter(_domains[i]);
}
}
/**
* @notice Handles an incoming message
* @param _origin The origin domain
* @param _sender The sender address
* @param _message The message
*/
// solhint-disable-next-line hyperlane/no-virtual-override
function handle(
uint32 _origin,
bytes32 _sender,
bytes calldata _message
) external payable virtual override onlyMailbox {
bytes32 _router = _mustHaveRemoteRouter(_origin);
require(_router == _sender, "Enrolled router does not match sender");
_handle(_origin, _sender, _message);
}
// ============ Virtual functions ============
function _handle(
uint32 _origin,
bytes32 _sender,
bytes calldata _message
) internal virtual;
// ============ Internal functions ============
/**
* @notice Set the router for a given domain
* @param _domain The domain
* @param _address The new router
*/
function _enrollRemoteRouter(
uint32 _domain,
bytes32 _address
) internal virtual {
_routers.set(_domain, _address);
}
/**
* @notice Remove the router for a given domain
* @param _domain The domain
*/
function _unenrollRemoteRouter(uint32 _domain) internal virtual {
require(_routers.remove(_domain), _domainNotFoundError(_domain));
}
/**
* @notice Return true if the given domain / router is the address of a remote Application Router
* @param _domain The domain of the potential remote Application Router
* @param _address The address of the potential remote Application Router
*/
function _isRemoteRouter(
uint32 _domain,
bytes32 _address
) internal view returns (bool) {
return routers(_domain) == _address;
}
/**
* @notice Assert that the given domain has an Application Router registered and return its address
* @param _domain The domain of the chain for which to get the Application Router
* @return _router The address of the remote Application Router on _domain
*/
function _mustHaveRemoteRouter(
uint32 _domain
) internal view returns (bytes32) {
(bool contained, bytes32 _router) = _routers.tryGet(_domain);
if (contained) {
return _router;
}
revert(_domainNotFoundError(_domain));
}
function _domainNotFoundError(
uint32 _domain
) internal pure returns (string memory) {
return
string.concat(
"No router enrolled for domain: ",
_domain.toString()
);
}
function _Router_dispatch(
uint32 _destinationDomain,
uint256 _value,
bytes memory _messageBody
) internal returns (bytes32) {
return
_Router_dispatch(
_destinationDomain,
_value,
_messageBody,
"",
address(hook)
);
}
function _Router_dispatch(
uint32 _destinationDomain,
uint256 _value,
bytes memory _messageBody,
bytes memory _hookMetadata,
address _hook
) internal returns (bytes32) {
bytes32 _router = _mustHaveRemoteRouter(_destinationDomain);
return
mailbox.dispatch{value: _value}(
_destinationDomain,
_router,
_messageBody,
_hookMetadata,
IPostDispatchHook(_hook)
);
}
function _Router_quoteDispatch(
uint32 _destinationDomain,
bytes memory _messageBody
) internal view returns (uint256) {
return
_Router_quoteDispatch(
_destinationDomain,
_messageBody,
"",
address(hook)
);
}
function _Router_quoteDispatch(
uint32 _destinationDomain,
bytes memory _messageBody,
bytes memory _hookMetadata,
address _hook
) internal view returns (uint256) {
bytes32 _router = _mustHaveRemoteRouter(_destinationDomain);
return
mailbox.quoteDispatch(
_destinationDomain,
_router,
_messageBody,
_hookMetadata,
IPostDispatchHook(_hook)
);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC4626.sol)
pragma solidity ^0.8.0;
import "../ERC20Upgradeable.sol";
import "../utils/SafeERC20Upgradeable.sol";
import "../../../interfaces/IERC4626Upgradeable.sol";
import "../../../utils/math/MathUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the ERC4626 "Tokenized Vault Standard" as defined in
* https://eips.ethereum.org/EIPS/eip-4626[EIP-4626].
*
* This extension allows the minting and burning of "shares" (represented using the ERC20 inheritance) in exchange for
* underlying "assets" through standardized {deposit}, {mint}, {redeem} and {burn} workflows. This contract extends
* the ERC20 standard. Any additional extensions included along it would affect the "shares" token represented by this
* contract and not the "assets" token which is an independent contract.
*
* [CAUTION]
* ====
* In empty (or nearly empty) ERC-4626 vaults, deposits are at high risk of being stolen through frontrunning
* with a "donation" to the vault that inflates the price of a share. This is variously known as a donation or inflation
* attack and is essentially a problem of slippage. Vault deployers can protect against this attack by making an initial
* deposit of a non-trivial amount of the asset, such that price manipulation becomes infeasible. Withdrawals may
* similarly be affected by slippage. Users can protect against this attack as well as unexpected slippage in general by
* verifying the amount received is as expected, using a wrapper that performs these checks such as
* https://github.com/fei-protocol/ERC4626#erc4626router-and-base[ERC4626Router].
*
* Since v4.9, this implementation uses virtual assets and shares to mitigate that risk. The `_decimalsOffset()`
* corresponds to an offset in the decimal representation between the underlying asset's decimals and the vault
* decimals. This offset also determines the rate of virtual shares to virtual assets in the vault, which itself
* determines the initial exchange rate. While not fully preventing the attack, analysis shows that the default offset
* (0) makes it non-profitable, as a result of the value being captured by the virtual shares (out of the attacker's
* donation) matching the attacker's expected gains. With a larger offset, the attack becomes orders of magnitude more
* expensive than it is profitable. More details about the underlying math can be found
* xref:erc4626.adoc#inflation-attack[here].
*
* The drawback of this approach is that the virtual shares do capture (a very small) part of the value being accrued
* to the vault. Also, if the vault experiences losses, the users try to exit the vault, the virtual shares and assets
* will cause the first user to exit to experience reduced losses in detriment to the last users that will experience
* bigger losses. Developers willing to revert back to the pre-v4.9 behavior just need to override the
* `_convertToShares` and `_convertToAssets` functions.
*
* To learn more, check out our xref:ROOT:erc4626.adoc[ERC-4626 guide].
* ====
*
* _Available since v4.7._
*/
abstract contract ERC4626Upgradeable is Initializable, ERC20Upgradeable, IERC4626Upgradeable {
using MathUpgradeable for uint256;
IERC20Upgradeable private _asset;
uint8 private _underlyingDecimals;
/**
* @dev Set the underlying asset contract. This must be an ERC20-compatible contract (ERC20 or ERC777).
*/
function __ERC4626_init(IERC20Upgradeable asset_) internal onlyInitializing {
__ERC4626_init_unchained(asset_);
}
function __ERC4626_init_unchained(IERC20Upgradeable asset_) internal onlyInitializing {
(bool success, uint8 assetDecimals) = _tryGetAssetDecimals(asset_);
_underlyingDecimals = success ? assetDecimals : 18;
_asset = asset_;
}
/**
* @dev Attempts to fetch the asset decimals. A return value of false indicates that the attempt failed in some way.
*/
function _tryGetAssetDecimals(IERC20Upgradeable asset_) private view returns (bool, uint8) {
(bool success, bytes memory encodedDecimals) = address(asset_).staticcall(
abi.encodeWithSelector(IERC20MetadataUpgradeable.decimals.selector)
);
if (success && encodedDecimals.length >= 32) {
uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
if (returnedDecimals <= type(uint8).max) {
return (true, uint8(returnedDecimals));
}
}
return (false, 0);
}
/**
* @dev Decimals are computed by adding the decimal offset on top of the underlying asset's decimals. This
* "original" value is cached during construction of the vault contract. If this read operation fails (e.g., the
* asset has not been created yet), a default of 18 is used to represent the underlying asset's decimals.
*
* See {IERC20Metadata-decimals}.
*/
function decimals() public view virtual override(IERC20MetadataUpgradeable, ERC20Upgradeable) returns (uint8) {
return _underlyingDecimals + _decimalsOffset();
}
/** @dev See {IERC4626-asset}. */
function asset() public view virtual override returns (address) {
return address(_asset);
}
/** @dev See {IERC4626-totalAssets}. */
function totalAssets() public view virtual override returns (uint256) {
return _asset.balanceOf(address(this));
}
/** @dev See {IERC4626-convertToShares}. */
function convertToShares(uint256 assets) public view virtual override returns (uint256) {
return _convertToShares(assets, MathUpgradeable.Rounding.Down);
}
/** @dev See {IERC4626-convertToAssets}. */
function convertToAssets(uint256 shares) public view virtual override returns (uint256) {
return _convertToAssets(shares, MathUpgradeable.Rounding.Down);
}
/** @dev See {IERC4626-maxDeposit}. */
function maxDeposit(address) public view virtual override returns (uint256) {
return type(uint256).max;
}
/** @dev See {IERC4626-maxMint}. */
function maxMint(address) public view virtual override returns (uint256) {
return type(uint256).max;
}
/** @dev See {IERC4626-maxWithdraw}. */
function maxWithdraw(address owner) public view virtual override returns (uint256) {
return _convertToAssets(balanceOf(owner), MathUpgradeable.Rounding.Down);
}
/** @dev See {IERC4626-maxRedeem}. */
function maxRedeem(address owner) public view virtual override returns (uint256) {
return balanceOf(owner);
}
/** @dev See {IERC4626-previewDeposit}. */
function previewDeposit(uint256 assets) public view virtual override returns (uint256) {
return _convertToShares(assets, MathUpgradeable.Rounding.Down);
}
/** @dev See {IERC4626-previewMint}. */
function previewMint(uint256 shares) public view virtual override returns (uint256) {
return _convertToAssets(shares, MathUpgradeable.Rounding.Up);
}
/** @dev See {IERC4626-previewWithdraw}. */
function previewWithdraw(uint256 assets) public view virtual override returns (uint256) {
return _convertToShares(assets, MathUpgradeable.Rounding.Up);
}
/** @dev See {IERC4626-previewRedeem}. */
function previewRedeem(uint256 shares) public view virtual override returns (uint256) {
return _convertToAssets(shares, MathUpgradeable.Rounding.Down);
}
/** @dev See {IERC4626-deposit}. */
function deposit(uint256 assets, address receiver) public virtual override returns (uint256) {
require(assets <= maxDeposit(receiver), "ERC4626: deposit more than max");
uint256 shares = previewDeposit(assets);
_deposit(_msgSender(), receiver, assets, shares);
return shares;
}
/** @dev See {IERC4626-mint}.
*
* As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
* In this case, the shares will be minted without requiring any assets to be deposited.
*/
function mint(uint256 shares, address receiver) public virtual override returns (uint256) {
require(shares <= maxMint(receiver), "ERC4626: mint more than max");
uint256 assets = previewMint(shares);
_deposit(_msgSender(), receiver, assets, shares);
return assets;
}
/** @dev See {IERC4626-withdraw}. */
function withdraw(uint256 assets, address receiver, address owner) public virtual override returns (uint256) {
require(assets <= maxWithdraw(owner), "ERC4626: withdraw more than max");
uint256 shares = previewWithdraw(assets);
_withdraw(_msgSender(), receiver, owner, assets, shares);
return shares;
}
/** @dev See {IERC4626-redeem}. */
function redeem(uint256 shares, address receiver, address owner) public virtual override returns (uint256) {
require(shares <= maxRedeem(owner), "ERC4626: redeem more than max");
uint256 assets = previewRedeem(shares);
_withdraw(_msgSender(), receiver, owner, assets, shares);
return assets;
}
/**
* @dev Internal conversion function (from assets to shares) with support for rounding direction.
*/
function _convertToShares(uint256 assets, MathUpgradeable.Rounding rounding) internal view virtual returns (uint256) {
return assets.mulDiv(totalSupply() + 10 ** _decimalsOffset(), totalAssets() + 1, rounding);
}
/**
* @dev Internal conversion function (from shares to assets) with support for rounding direction.
*/
function _convertToAssets(uint256 shares, MathUpgradeable.Rounding rounding) internal view virtual returns (uint256) {
return shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** _decimalsOffset(), rounding);
}
/**
* @dev Deposit/mint common workflow.
*/
function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual {
// If _asset is ERC777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the
// `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer,
// calls the vault, which is assumed not malicious.
//
// Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the
// assets are transferred and before the shares are minted, which is a valid state.
// slither-disable-next-line reentrancy-no-eth
SafeERC20Upgradeable.safeTransferFrom(_asset, caller, address(this), assets);
_mint(receiver, shares);
emit Deposit(caller, receiver, assets, shares);
}
/**
* @dev Withdraw/redeem common workflow.
*/
function _withdraw(
address caller,
address receiver,
address owner,
uint256 assets,
uint256 shares
) internal virtual {
if (caller != owner) {
_spendAllowance(owner, caller, shares);
}
// If _asset is ERC777, `transfer` can trigger a reentrancy AFTER the transfer happens through the
// `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer,
// calls the vault, which is assumed not malicious.
//
// Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the
// shares are burned and after the assets are transferred, which is a valid state.
_burn(owner, shares);
SafeERC20Upgradeable.safeTransfer(_asset, receiver, assets);
emit Withdraw(caller, receiver, owner, assets, shares);
}
function _decimalsOffset() internal view virtual returns (uint8) {
return 0;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20Upgradeable {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.22;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableMap.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableMap.js.
pragma solidity ^0.8.0;
import "./EnumerableSet.sol";
/**
* @dev Library for managing an enumerable variant of Solidity's
* https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
* type.
*
* Maps have the following properties:
*
* - Entries are added, removed, and checked for existence in constant time
* (O(1)).
* - Entries are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableMap for EnumerableMap.UintToAddressMap;
*
* // Declare a set state variable
* EnumerableMap.UintToAddressMap private myMap;
* }
* ```
*
* The following map types are supported:
*
* - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
* - `address -> uint256` (`AddressToUintMap`) since v4.6.0
* - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0
* - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
* - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableMap.
* ====
*/
library EnumerableMap {
using EnumerableSet for EnumerableSet.Bytes32Set;
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Map type with
// bytes32 keys and values.
// The Map implementation uses private functions, and user-facing
// implementations (such as Uint256ToAddressMap) are just wrappers around
// the underlying Map.
// This means that we can only create new EnumerableMaps for types that fit
// in bytes32.
struct Bytes32ToBytes32Map {
// Storage of keys
EnumerableSet.Bytes32Set _keys;
mapping(bytes32 => bytes32) _values;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal returns (bool) {
map._values[key] = value;
return map._keys.add(key);
}
/**
* @dev Removes a key-value pair from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
delete map._values[key];
return map._keys.remove(key);
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
return map._keys.contains(key);
}
/**
* @dev Returns the number of key-value pairs in the map. O(1).
*/
function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
return map._keys.length();
}
/**
* @dev Returns the key-value pair stored at position `index` in the map. O(1).
*
* Note that there are no guarantees on the ordering of entries inside the
* array, and it may change when more entries are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
bytes32 key = map._keys.at(index);
return (key, map._values[key]);
}
/**
* @dev Tries to returns the value associated with `key`. O(1).
* Does not revert if `key` is not in the map.
*/
function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
bytes32 value = map._values[key];
if (value == bytes32(0)) {
return (contains(map, key), bytes32(0));
} else {
return (true, value);
}
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
bytes32 value = map._values[key];
require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
return value;
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryGet}.
*/
function get(
Bytes32ToBytes32Map storage map,
bytes32 key,
string memory errorMessage
) internal view returns (bytes32) {
bytes32 value = map._values[key];
require(value != 0 || contains(map, key), errorMessage);
return value;
}
/**
* @dev Return the an array containing all the keys
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {
return map._keys.values();
}
// UintToUintMap
struct UintToUintMap {
Bytes32ToBytes32Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {
return set(map._inner, bytes32(key), bytes32(value));
}
/**
* @dev Removes a value from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
return remove(map._inner, bytes32(key));
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
return contains(map._inner, bytes32(key));
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(UintToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the map. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (uint256(key), uint256(value));
}
/**
* @dev Tries to returns the value associated with `key`. O(1).
* Does not revert if `key` is not in the map.
*/
function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
return (success, uint256(value));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(key)));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryGet}.
*/
function get(UintToUintMap storage map, uint256 key, string memory errorMessage) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(key), errorMessage));
}
/**
* @dev Return the an array containing all the keys
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {
bytes32[] memory store = keys(map._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintToAddressMap
struct UintToAddressMap {
Bytes32ToBytes32Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return remove(map._inner, bytes32(key));
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return contains(map._inner, bytes32(key));
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(UintToAddressMap storage map) internal view returns (uint256) {
return length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the map. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (uint256(key), address(uint160(uint256(value))));
}
/**
* @dev Tries to returns the value associated with `key`. O(1).
* Does not revert if `key` is not in the map.
*/
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
return (success, address(uint160(uint256(value))));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint160(uint256(get(map._inner, bytes32(key)))));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryGet}.
*/
function get(
UintToAddressMap storage map,
uint256 key,
string memory errorMessage
) internal view returns (address) {
return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
}
/**
* @dev Return the an array containing all the keys
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {
bytes32[] memory store = keys(map._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressToUintMap
struct AddressToUintMap {
Bytes32ToBytes32Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {
return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
}
/**
* @dev Removes a value from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(AddressToUintMap storage map, address key) internal returns (bool) {
return remove(map._inner, bytes32(uint256(uint160(key))));
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
return contains(map._inner, bytes32(uint256(uint160(key))));
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(AddressToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the map. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (address(uint160(uint256(key))), uint256(value));
}
/**
* @dev Tries to returns the value associated with `key`. O(1).
* Does not revert if `key` is not in the map.
*/
function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
return (success, uint256(value));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryGet}.
*/
function get(
AddressToUintMap storage map,
address key,
string memory errorMessage
) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
}
/**
* @dev Return the an array containing all the keys
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function keys(AddressToUintMap storage map) internal view returns (address[] memory) {
bytes32[] memory store = keys(map._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// Bytes32ToUintMap
struct Bytes32ToUintMap {
Bytes32ToBytes32Map _inner;
}
/**
* @dev Adds a key-value pair to a map, or updates the value for an existing
* key. O(1).
*
* Returns true if the key was added to the map, that is if it was not
* already present.
*/
function set(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {
return set(map._inner, key, bytes32(value));
}
/**
* @dev Removes a value from a map. O(1).
*
* Returns true if the key was removed from the map, that is if it was present.
*/
function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
return remove(map._inner, key);
}
/**
* @dev Returns true if the key is in the map. O(1).
*/
function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
return contains(map._inner, key);
}
/**
* @dev Returns the number of elements in the map. O(1).
*/
function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
/**
* @dev Returns the element stored at position `index` in the map. O(1).
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (key, uint256(value));
}
/**
* @dev Tries to returns the value associated with `key`. O(1).
* Does not revert if `key` is not in the map.
*/
function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, key);
return (success, uint256(value));
}
/**
* @dev Returns the value associated with `key`. O(1).
*
* Requirements:
*
* - `key` must be in the map.
*/
function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
return uint256(get(map._inner, key));
}
/**
* @dev Same as {get}, with a custom error message when `key` is not in the map.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryGet}.
*/
function get(
Bytes32ToUintMap storage map,
bytes32 key,
string memory errorMessage
) internal view returns (uint256) {
return uint256(get(map._inner, key, errorMessage));
}
/**
* @dev Return the an array containing all the keys
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {
bytes32[] memory store = keys(map._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
interface IMessageRecipient {
function handle(
uint32 _origin,
bytes32 _sender,
bytes calldata _message
) external payable;
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
// ============ Internal Imports ============
import {IMailbox} from "../interfaces/IMailbox.sol";
import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
import {IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
import {Message} from "../libs/Message.sol";
import {PackageVersioned} from "../PackageVersioned.sol";
// ============ External Imports ============
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
abstract contract MailboxClient is OwnableUpgradeable, PackageVersioned {
using Message for bytes;
event HookSet(address _hook);
event IsmSet(address _ism);
IMailbox public immutable mailbox;
uint32 public immutable localDomain;
IPostDispatchHook public hook;
IInterchainSecurityModule internal _interchainSecurityModule;
uint256[48] private __GAP; // gap for upgrade safety
// ============ Modifiers ============
modifier onlyContract(address _contract) {
require(
Address.isContract(_contract),
"MailboxClient: invalid mailbox"
);
_;
}
modifier onlyContractOrNull(address _contract) {
require(
Address.isContract(_contract) || _contract == address(0),
"MailboxClient: invalid contract setting"
);
_;
}
/**
* @notice Only accept messages from a Hyperlane Mailbox contract
*/
modifier onlyMailbox() {
require(
msg.sender == address(mailbox),
"MailboxClient: sender not mailbox"
);
_;
}
constructor(address _mailbox) onlyContract(_mailbox) {
mailbox = IMailbox(_mailbox);
localDomain = mailbox.localDomain();
_transferOwnership(msg.sender);
}
function interchainSecurityModule()
external
view
virtual
returns (IInterchainSecurityModule)
{
return _interchainSecurityModule;
}
/**
* @notice Sets the address of the application's custom hook.
* @param _hook The address of the hook contract.
*/
function setHook(
address _hook
) public virtual onlyContractOrNull(_hook) onlyOwner {
hook = IPostDispatchHook(_hook);
emit HookSet(_hook);
}
/**
* @notice Sets the address of the application's custom interchain security module.
* @param _module The address of the interchain security module contract.
*/
function setInterchainSecurityModule(
address _module
) public onlyContractOrNull(_module) onlyOwner {
_interchainSecurityModule = IInterchainSecurityModule(_module);
emit IsmSet(_module);
}
// ======== Initializer =========
function _MailboxClient_initialize(
address _hook,
address __interchainSecurityModule,
address _owner
) internal onlyInitializing {
__Ownable_init();
setHook(_hook);
setInterchainSecurityModule(__interchainSecurityModule);
_transferOwnership(_owner);
}
function _isLatestDispatched(bytes32 id) internal view returns (bool) {
return mailbox.latestDispatchedId() == id;
}
function _isDelivered(bytes32 id) internal view returns (bool) {
return mailbox.delivered(id);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[45] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
import "../extensions/IERC20PermitUpgradeable.sol";
import "../../../utils/AddressUpgradeable.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20Upgradeable {
using AddressUpgradeable for address;
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
* Revert on invalid signature.
*/
function safePermit(
IERC20PermitUpgradeable token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20Upgradeable token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && AddressUpgradeable.isContract(address(token));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4626.sol)
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20Upgradeable.sol";
import "../token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
/**
* @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
* https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
*
* _Available since v4.7._
*/
interface IERC4626Upgradeable is IERC20Upgradeable, IERC20MetadataUpgradeable {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev 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}.
*/
interface IERC165 {
/**
* @dev 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);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
import {IInterchainSecurityModule} from "./IInterchainSecurityModule.sol";
import {IPostDispatchHook} from "./hooks/IPostDispatchHook.sol";
interface IMailbox {
// ============ Events ============
/**
* @notice Emitted when a new message is dispatched via Hyperlane
* @param sender The address that dispatched the message
* @param destination The destination domain of the message
* @param recipient The message recipient address on `destination`
* @param message Raw bytes of message
*/
event Dispatch(
address indexed sender,
uint32 indexed destination,
bytes32 indexed recipient,
bytes message
);
/**
* @notice Emitted when a new message is dispatched via Hyperlane
* @param messageId The unique message identifier
*/
event DispatchId(bytes32 indexed messageId);
/**
* @notice Emitted when a Hyperlane message is processed
* @param messageId The unique message identifier
*/
event ProcessId(bytes32 indexed messageId);
/**
* @notice Emitted when a Hyperlane message is delivered
* @param origin The origin domain of the message
* @param sender The message sender address on `origin`
* @param recipient The address that handled the message
*/
event Process(
uint32 indexed origin,
bytes32 indexed sender,
address indexed recipient
);
function localDomain() external view returns (uint32);
function delivered(bytes32 messageId) external view returns (bool);
function defaultIsm() external view returns (IInterchainSecurityModule);
function defaultHook() external view returns (IPostDispatchHook);
function requiredHook() external view returns (IPostDispatchHook);
function latestDispatchedId() external view returns (bytes32);
function nonce() external view returns (uint32);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody
) external view returns (uint256 fee);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata body,
bytes calldata defaultHookMetadata
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody,
bytes calldata defaultHookMetadata
) external view returns (uint256 fee);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata body,
bytes calldata customHookMetadata,
IPostDispatchHook customHook
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody,
bytes calldata customHookMetadata,
IPostDispatchHook customHook
) external view returns (uint256 fee);
function process(
bytes calldata metadata,
bytes calldata message
) external payable;
function recipientIsm(
address recipient
) external view returns (IInterchainSecurityModule module);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20PermitUpgradeable {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}{
"optimizer": {
"enabled": true,
"runs": 999999
},
"evmVersion": "paris",
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"_erc20","type":"address"},{"internalType":"address","name":"_mailbox","type":"address"},{"internalType":"contract IMessageTransmitterV2","name":"_messageTransmitter","type":"address"},{"internalType":"contract ITokenMessengerV2","name":"_tokenMessenger","type":"address"},{"internalType":"uint256","name":"_maxFeeBps","type":"uint256"},{"internalType":"uint32","name":"_minFinalityThreshold","type":"uint32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CircleDomainNotConfigured","type":"error"},{"inputs":[],"name":"HyperlaneDomainNotConfigured","type":"error"},{"inputs":[],"name":"InvalidBurnSender","type":"error"},{"inputs":[],"name":"InvalidCCTPVersion","type":"error"},{"inputs":[],"name":"InvalidCircleRecipient","type":"error"},{"inputs":[],"name":"InvalidMessageId","type":"error"},{"inputs":[],"name":"InvalidMintAmount","type":"error"},{"inputs":[],"name":"InvalidMintRecipient","type":"error"},{"inputs":[],"name":"InvalidTokenMessageRecipient","type":"error"},{"inputs":[],"name":"MaxFeeTooHigh","type":"error"},{"inputs":[],"name":"MessageNotDispatched","type":"error"},{"inputs":[],"name":"NotMessageTransmitter","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"string[]","name":"urls","type":"string[]"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes4","name":"callbackFunction","type":"bytes4"},{"internalType":"bytes","name":"extraData","type":"bytes"}],"name":"OffchainLookup","type":"error"},{"inputs":[],"name":"UnauthorizedCircleSender","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"hyperlaneDomain","type":"uint32"},{"indexed":false,"internalType":"uint32","name":"circleDomain","type":"uint32"}],"name":"DomainAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeRecipient","type":"address"}],"name":"FeeRecipientSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"domain","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"gas","type":"uint256"}],"name":"GasSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_hook","type":"address"}],"name":"HookSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_ism","type":"address"}],"name":"IsmSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"origin","type":"uint32"},{"indexed":true,"internalType":"bytes32","name":"recipient","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"ReceivedTransferRemote","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"destination","type":"uint32"},{"indexed":true,"internalType":"bytes32","name":"recipient","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"SentTransferRemote","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string[]","name":"newUrls","type":"string[]"}],"name":"UrlsChanged","type":"event"},{"inputs":[],"name":"PACKAGE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_hyperlaneDomain","type":"uint32"},{"internalType":"uint32","name":"_circleDomain","type":"uint32"}],"name":"addDomain","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"hyperlane","type":"uint32"},{"internalType":"uint32","name":"circle","type":"uint32"}],"internalType":"struct Domain[]","name":"domains","type":"tuple[]"}],"name":"addDomains","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_circleDomain","type":"uint32"}],"name":"circleDomainToHyperlaneDomain","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"destinationDomain","type":"uint32"}],"name":"destinationGas","outputs":[{"internalType":"uint256","name":"gasLimit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"domains","outputs":[{"internalType":"uint32[]","name":"","type":"uint32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_domain","type":"uint32"},{"internalType":"bytes32","name":"_router","type":"bytes32"}],"name":"enrollRemoteRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32[]","name":"_domains","type":"uint32[]"},{"internalType":"bytes32[]","name":"_addresses","type":"bytes32[]"}],"name":"enrollRemoteRouters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_message","type":"bytes"}],"name":"getOffchainVerifyInfo","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_origin","type":"uint32"},{"internalType":"bytes32","name":"_sender","type":"bytes32"},{"internalType":"bytes","name":"_message","type":"bytes"}],"name":"handle","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint32","name":"sourceDomain","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"bytes","name":"messageBody","type":"bytes"}],"name":"handleReceiveFinalizedMessage","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"sourceDomain","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"bytes","name":"messageBody","type":"bytes"}],"name":"handleReceiveUnfinalizedMessage","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"hook","outputs":[{"internalType":"contract IPostDispatchHook","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hookType","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint32","name":"_hyperlaneDomain","type":"uint32"}],"name":"hyperlaneDomainToCircleDomain","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_hook","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"string[]","name":"__urls","type":"string[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"interchainSecurityModule","outputs":[{"internalType":"contract IInterchainSecurityModule","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageId","type":"bytes32"}],"name":"isVerified","outputs":[{"internalType":"bool","name":"verified","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"localDomain","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mailbox","outputs":[{"internalType":"contract IMailbox","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFeeBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageTransmitter","outputs":[{"internalType":"contract IMessageTransmitter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minFinalityThreshold","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moduleType","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"metadata","type":"bytes"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"postDispatch","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"metadata","type":"bytes"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"quoteDispatch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_destinationDomain","type":"uint32"}],"name":"quoteGasPayment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_destination","type":"uint32"},{"internalType":"bytes32","name":"_recipient","type":"bytes32"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"quoteTransferRemote","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Quote[]","name":"quotes","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_domain","type":"uint32"}],"name":"routers","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"scale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"domain","type":"uint32"},{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"setDestinationGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"domain","type":"uint32"},{"internalType":"uint256","name":"gas","type":"uint256"}],"internalType":"struct GasRouter.GasRouterConfig[]","name":"gasConfigs","type":"tuple[]"}],"name":"setDestinationGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_hook","type":"address"}],"name":"setHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_module","type":"address"}],"name":"setInterchainSecurityModule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string[]","name":"__urls","type":"string[]"}],"name":"setUrls","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"supportsMetadata","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenMessenger","outputs":[{"internalType":"contract ITokenMessenger","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_destination","type":"uint32"},{"internalType":"bytes32","name":"_recipient","type":"bytes32"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferRemote","outputs":[{"internalType":"bytes32","name":"messageId","type":"bytes32"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_domain","type":"uint32"}],"name":"unenrollRemoteRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32[]","name":"_domains","type":"uint32[]"}],"name":"unenrollRemoteRouters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"urls","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_metadata","type":"bytes"},{"internalType":"bytes","name":"_hyperlaneMessage","type":"bytes"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wrappedToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
0x60806040526004361061031e5760003560e01c80638bd90b82116101a5578063de523cf3116100ec578063f2ed8c5311610095578063f7362be11161006f578063f7362be114610a04578063f7e83aee14610a24578063f83c1a6b14610a44578063fc0c546a14610a6457600080fd5b8063f2ed8c5314610990578063f2fde38b146109b0578063f51e181a146109d057600080fd5b8063e74b981b116100c6578063e74b981b14610930578063e9198bf914610950578063efae508a1461097057600080fd5b8063de523cf3146108e9578063e445e7dd146108fc578063e5320bb91461091057600080fd5b8063b1bd64361161014e578063bf769a3f11610128578063bf769a3f14610851578063c181b27314610885578063d5438eae146108b557600080fd5b8063b1bd6436146107f1578063b49c53a714610811578063bbac9bc81461083157600080fd5b806393c448471161017f57806393c4484714610747578063996c6cc31461079d578063aaccd230146107d157600080fd5b80638bd90b82146106bb5780638d3638f4146106e85780638da5cb5b1461071c57600080fd5b8063469048401161026957806371a15b38116102125780637c92f219116101ec5780637c92f219146103585780637f5a7c7b1461067b57806381b4e8b4146106a857600080fd5b806371a15b38146105fa578063775313a11461061a5780637b04c1811461064757600080fd5b80636465e69f116102435780636465e69f1461059e5780636cc895a9146105c5578063715018a6146105e557600080fd5b8063469048401461052157806349d462ef1461056b57806356d5d4751461058b57600080fd5b80632b5c2094116102cb5780633dfd3873116102a55780633dfd387314610486578063440df4f4146104a657806346117830146104c857600080fd5b80632b5c2094146104165780632c73dc4a146104365780632ead72f61461045857600080fd5b8063163d68e4116102fc578063163d68e41461038d57806316a0f250146103ad5780631c7fac40146103f657600080fd5b8063086011b9146103235780630e72cc061461033857806311cffb6714610358575b600080fd5b610336610331366004614b65565b610a97565b005b34801561034457600080fd5b50610336610353366004614bf3565b610b44565b34801561036457600080fd5b50610378610373366004614c29565b610c8d565b60405190151581526020015b60405180910390f35b34801561039957600080fd5b506103366103a8366004614d63565b610caf565b3480156103b957600080fd5b506103e17f00000000000000000000000000000000000000000000000000000000000003e881565b60405163ffffffff9091168152602001610384565b34801561040257600080fd5b50610336610411366004614f38565b610d2f565b34801561042257600080fd5b506103e1610431366004614f9a565b610fc9565b34801561044257600080fd5b5061044b611049565b6040516103849190615023565b34801561046457600080fd5b50610478610473366004614f9a565b611122565b604051908152602001610384565b34801561049257600080fd5b506103366104a1366004614bf3565b611141565b3480156104b257600080fd5b506104bb611282565b60405161038491906150a5565b3480156104d457600080fd5b506104fc7f00000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d81565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610384565b34801561052d57600080fd5b507f721d42344eebce0a76684e8fddd9c81a84afda39f3019e5a078a53853f098d115473ffffffffffffffffffffffffffffffffffffffff166104fc565b34801561057757600080fd5b506103366105863660046150ef565b611293565b610336610599366004615119565b6112a5565b3480156105aa57600080fd5b506105b3600781565b60405160ff9091168152602001610384565b3480156105d157600080fd5b506103366105e0366004615167565b611419565b3480156105f157600080fd5b50610336611500565b34801561060657600080fd5b506103366106153660046151e1565b611514565b34801561062657600080fd5b50610478610635366004614f9a565b60ca6020526000908152604090205481565b34801561065357600080fd5b506104fc7f00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b6481565b34801561068757600080fd5b506065546104fc9073ffffffffffffffffffffffffffffffffffffffff1681565b6104786106b6366004615223565b611569565b3480156106c757600080fd5b506106db6106d6366004615223565b6115f2565b6040516103849190615256565b3480156106f457600080fd5b506103e17f000000000000000000000000000000000000000000000000000000000000008281565b34801561072857600080fd5b5060335473ffffffffffffffffffffffffffffffffffffffff166104fc565b34801561075357600080fd5b506107906040518060400160405280600681526020017f31302e302e34000000000000000000000000000000000000000000000000000081525081565b60405161038491906152bb565b3480156107a957600080fd5b506104fc7f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad681565b3480156107dd57600080fd5b506104786107ec366004614b65565b611790565b3480156107fd57600080fd5b5061033661080c3660046152ce565b611834565b34801561081d57600080fd5b5061033661082c3660046150ef565b6118aa565b34801561083d57600080fd5b5061033661084c366004615343565b6118bc565b34801561085d57600080fd5b506104787f000000000000000000000000000000000000000000000000000000000000000181565b34801561089157600080fd5b506103786108a0366004615379565b60d26020526000908152604090205460ff1681565b3480156108c157600080fd5b506104fc7f0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e81565b3480156108f557600080fd5b50306104fc565b34801561090857600080fd5b50600f6105b3565b34801561091c57600080fd5b5061037861092b366004615343565b611924565b34801561093c57600080fd5b5061033661094b366004614bf3565b611949565b34801561095c57600080fd5b5061033661096b366004615392565b611a63565b34801561097c57600080fd5b5061033661098b366004614f9a565b611b42565b34801561099c57600080fd5b506104786109ab366004614f9a565b611b56565b3480156109bc57600080fd5b506103366109cb366004614bf3565b611b93565b3480156109dc57600080fd5b506104787f000000000000000000000000000000000000000000000000000000000000000181565b348015610a1057600080fd5b506103e1610a1f366004614f9a565b611c47565b348015610a3057600080fd5b50610378610a3f366004614b65565b611cc0565b348015610a5057600080fd5b50610336610a5f3660046153f2565b611f2e565b348015610a7057600080fd5b507f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad66104fc565b610aa18484611924565b610b32576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4162737472616374506f73744469737061746368486f6f6b3a20696e76616c6960448201527f64206d657461646174612076617269616e74000000000000000000000000000060648201526084015b60405180910390fd5b610b3e8484848461200c565b50505050565b8073ffffffffffffffffffffffffffffffffffffffff81163b151580610b7e575073ffffffffffffffffffffffffffffffffffffffff8116155b610c0a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602760248201527f4d61696c626f78436c69656e743a20696e76616c696420636f6e74726163742060448201527f73657474696e67000000000000000000000000000000000000000000000000006064820152608401610b29565b610c126120d8565b606680547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff84169081179091556040519081527fc47cbcc588c67679e52261c45cc315e56562f8d0ccaba16facb9093ff9498799906020015b60405180910390a15050565b6000610ca58686610ca085870187615379565b612159565b9695505050505050565b610cb76120d8565b60005b81518163ffffffff161015610d2b57610d19828263ffffffff1681518110610ce457610ce4615425565b602002602001015160000151838363ffffffff1681518110610d0857610d08615425565b602002602001015160200151611f2e565b80610d2381615483565b915050610cba565b5050565b600054610100900460ff1615808015610d4f5750600054600160ff909116105b80610d695750303b158015610d69575060005460ff166001145b610df5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a65640000000000000000000000000000000000006064820152608401610b29565b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790558015610e5357600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b610e5f8460008561225b565b610e6882611419565b6040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d811660048301527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60248301527f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad6169063095ea7b3906044016020604051808303816000875af1158015610f3c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f6091906154a6565b508015610b3e57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a150505050565b63ffffffff808216600081815260d06020908152604080832081518083019092525480861680835264010000000090910490951691810191909152909290911461103f576040517ffdf48e5d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6020015192915050565b606060cf805480602002602001604051908101604052809291908181526020016000905b8282101561111957838290600052602060002001805461108c906154c8565b80601f01602080910402602001604051908101604052809291908181526020018280546110b8906154c8565b80156111055780601f106110da57610100808354040283529160200191611105565b820191906000526020600020905b8154815290600101906020018083116110e857829003601f168201915b50505050508152602001906001019061106d565b50505050905090565b600080611139609763ffffffff8086169061231516565b949350505050565b8073ffffffffffffffffffffffffffffffffffffffff81163b15158061117b575073ffffffffffffffffffffffffffffffffffffffff8116155b611207576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602760248201527f4d61696c626f78436c69656e743a20696e76616c696420636f6e74726163742060448201527f73657474696e67000000000000000000000000000000000000000000000000006064820152608401610b29565b61120f6120d8565b606580547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff84169081179091556040519081527f4eab7b127c764308788622363ad3e9532de3dfba7845bd4f84c125a22544255a90602001610c81565b606061128e609761232e565b905090565b61129b6120d8565b610d2b82826123df565b3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e161461136a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f4d61696c626f78436c69656e743a2073656e646572206e6f74206d61696c626f60448201527f78000000000000000000000000000000000000000000000000000000000000006064820152608401610b29565b60006113758561242d565b9050838114611406576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f456e726f6c6c656420726f7574657220646f6573206e6f74206d61746368207360448201527f656e6465720000000000000000000000000000000000000000000000000000006064820152608401610b29565b61141285858585612492565b5050505050565b6114216120d8565b60008151116114b2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f4162737472616374436369705265616449736d3a2075726c732063616e6e6f7460448201527f20626520656d70747900000000000000000000000000000000000000000000006064820152608401610b29565b80516114c59060cf906020840190614a6e565b507f698ec4bf77690368abfaca0b66e51916585a0ca8b23e7925844ea841a4e7a503816040516114f59190615023565b60405180910390a150565b6115086120d8565b6115126000612504565b565b61151c6120d8565b8060005b81811015610b3e5761155784848381811061153d5761153d615425565b90506020020160208101906115529190614f9a565b61257b565b61156260018261554a565b9050611520565b600080600061157a868686346125d0565b9150915060006115898761242d565b9050600061159688610fc9565b905060006115a4858861554a565b90506115b3828983888761267e565b60408051602081018a905280820183905281518082038301815260609091019091526115e28a8a8a8885612798565b96505050505050505b9392505050565b60408051600380825260808201909252606091816020015b604080518082019091526000808252602082015281526020019060019003908161160a5790505090506040518060400160405280600073ffffffffffffffffffffffffffffffffffffffff168152602001611666868686612808565b8152508160008151811061167c5761167c615425565b6020026020010181905250600061169485858561283c565b91505060405180604001604052806116c97f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad690565b73ffffffffffffffffffffffffffffffffffffffff1681526020016116ee838661554a565b8152508260018151811061170457611704615425565b602002602001018190525060405180604001604052806117417f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad690565b73ffffffffffffffffffffffffffffffffffffffff168152602001611767878787612aaf565b8152508260028151811061177d5761177d615425565b6020026020010181905250509392505050565b600061179c8585611924565b611828576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4162737472616374506f73744469737061746368486f6f6b3a20696e76616c6960448201527f64206d657461646174612076617269616e7400000000000000000000000000006064820152608401610b29565b60005b95945050505050565b61183c6120d8565b60005b818110156118a55761189383838381811061185c5761185c615425565b6118729260206040909202019081019150614f9a565b84848481811061188457611884615425565b905060400201602001356123df565b61189e60018261554a565b905061183f565b505050565b6118b26120d8565b610d2b8282612ae9565b3060cf6118c98484612aff565b6040517f556f1830000000000000000000000000000000000000000000000000000000008152610b29939291907ff7e83aee0000000000000000000000000000000000000000000000000000000090879087906004016155a6565b60008115806119405750600161193a8484612b92565b61ffff16145b90505b92915050565b6119516120d8565b3073ffffffffffffffffffffffffffffffffffffffff8216036119d0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f46656520726563697069656e742063616e6e6f742062652073656c66000000006044820152606401610b29565b807f721d42344eebce0a76684e8fddd9c81a84afda39f3019e5a078a53853f098d1180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92831617905560405190821681527fbf9a9534339a9d6b81696e05dcfb614b7dc518a31d48be3cfb757988381fb323906020016114f5565b611a6b6120d8565b828114611ad4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600760248201527f216c656e677468000000000000000000000000000000000000000000000000006044820152606401610b29565b8260005b81811015611b3a57611b28868683818110611af557611af5615425565b9050602002016020810190611b0a9190614f9a565b858584818110611b1c57611b1c615425565b90506020020135612ae9565b611b3360018261554a565b9050611ad8565b505050505050565b611b4a6120d8565b611b538161257b565b50565b60006119438260405180602001604052806000815250611b7585612be3565b60655473ffffffffffffffffffffffffffffffffffffffff16612c05565b611b9b6120d8565b73ffffffffffffffffffffffffffffffffffffffff8116611c3e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610b29565b611b5381612504565b63ffffffff808216600081815260d1602090815260408083208151808301909252548086168252640100000000900490941690840181905290929114611cb9576040517f8b71ee3b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5192915050565b600060d26000611d0585858080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250612ccf92505050565b815260208101919091526040016000205460ff1615611d2657506001611139565b600080611d358688018861573b565b915091506000611d46836000612cda565b90506000611d5382612cf5565b90507f00000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603611e105730611db38888612d2a565b73ffffffffffffffffffffffffffffffffffffffff1614611e00576040517fcefc141d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b611e0b878784612d39565b611e6a565b3073ffffffffffffffffffffffffffffffffffffffff821603611e3857611e0b878784612eda565b6040517f06fb552600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040517f57ecfd2800000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b6416906357ecfd2890611ede908790879060040161579f565b6020604051808303816000875af1158015611efd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611f2191906154a6565b9998505050505050505050565b611f366120d8565b60408051808201825263ffffffff8481168083528482166020808501828152600084815260d083528781209651875492519087167fffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000938416176401000000009188168202179097558751808901895285815280840185815285835260d18552918990209051815492519088169290931691909117919095169095029490941790925592519081527f86eee369bdd5e8620b595131597759ddadaf57f38cc5f5f76172ad2b60c9c1f4910160405180910390a25050565b600061204d83838080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250612ccf92505050565b905061205881612faf565b61208e576040517f9bad993b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600061209a8484613048565b905060006120a78261242d565b905060006120b483610fc9565b90506120c181838661306b565b6120ce888888884761313b565b5050505050505050565b60335473ffffffffffffffffffffffffffffffffffffffff163314611512576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610b29565b60003373ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b6416146121ca576040517f067cdff000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006121d585611c47565b9050836121e18261242d565b14612218576040517f86519bc900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5050600081815260d26020526040902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660019081179091559392505050565b600054610100900460ff166122f2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610b29565b6122fa61321e565b61230383611141565b61230c82610b44565b6118a581612504565b60008061232284846132bd565b915091505b9250929050565b6060600061233b836132f7565b9050805167ffffffffffffffff81111561235757612357614c98565b604051908082528060200260200182016040528015612380578160200160208202803683370190505b50915060005b81518110156123d8578181815181106123a1576123a1615425565b60200260200101518382815181106123bb576123bb615425565b63ffffffff90921660209283029190910190910152600101612386565b5050919050565b63ffffffff8216600081815260ca6020908152604091829020849055815192835282018390527fc3de732a98b24a2b5c6f67e8a7fb057ffc14046b83968a2c73e4148d2fba978b9101610c81565b60008080612445609763ffffffff8087169061231516565b915091508115612456579392505050565b61245f84613388565b6040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2991906152bb565b600061249e83836133bf565b905060006124ac84846133e8565b9050818663ffffffff167fba20947a325f450d232530e5f5fce293e7963499d5309a07cee84a269f2f15a6836040516124e791815260200190565b60405180910390a3611b3a6124fb836133f8565b610d2b836134a1565b6033805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b61258f609763ffffffff808416906134cd16565b61259882613388565b90610d2b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2991906152bb565b6000806000806125e188888861283c565b915091506125f0888888612aaf565b93506000846125ff838961554a565b612609919061554a565b9050612614816134d9565b811561262457612624838361351b565b73ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad61661266e5761266981876157c4565b612670565b855b935050505094509492505050565b6040517f8e0250ee0000000000000000000000000000000000000000000000000000000081526004810184905263ffffffff86811660248301526044820186905273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad6811660648401526084830184905260a483018590527f00000000000000000000000000000000000000000000000000000000000003e890911660c48301527f00000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d1690638e0250ee9060e401600060405180830381600087803b15801561277957600080fd5b505af115801561278d573d6000803e3d6000fd5b505050505050505050565b6000848663ffffffff167fd229aacb94204188fe8042965fa6b269c62dc5818b21238779ab64bdd17efeec866040516127d391815260200190565b60405180910390a3610ca58684846127ea8a612be3565b60655473ffffffffffffffffffffffffffffffffffffffff1661355c565b60408051602081018490528082018390528151808203830181526060909101909152600090611139908590611b7587612be3565b60008061287d7f721d42344eebce0a76684e8fddd9c81a84afda39f3019e5a078a53853f098d115473ffffffffffffffffffffffffffffffffffffffff1690565b915073ffffffffffffffffffffffffffffffffffffffff82166128a257506000612aa7565b6040517f8bd90b8200000000000000000000000000000000000000000000000000000000815263ffffffff86166004820152602481018590526044810184905260009073ffffffffffffffffffffffffffffffffffffffff841690638bd90b8290606401600060405180830381865afa158015612923573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820160405261296991908101906157d7565b9050805160000361297e575060009050612aa7565b805160011480156129f857507f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad673ffffffffffffffffffffffffffffffffffffffff16816000815181106129d4576129d4615425565b60200260200101516000015173ffffffffffffffffffffffffffffffffffffffff16145b612a84576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f46756e6769626c65546f6b656e526f757465723a20666565206d757374206d6160448201527f74636820746f6b656e00000000000000000000000000000000000000000000006064820152608401610b29565b80600081518110612a9757612a97615425565b6020026020010151602001519150505b935093915050565b6000611139827f0000000000000000000000000000000000000000000000000000000000000001612ae2816127106157c4565b600161361a565b610d2b609763ffffffff80851690849061366b16565b60608282604051602401612b1492919061588b565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f5d1c214a00000000000000000000000000000000000000000000000000000000179052905092915050565b6000612b9f81600261589f565b60ff16821015612bb157506000611943565b82600083612bc082600261589f565b60ff1692612bd0939291906158b8565b612bd9916158e2565b60f01c9392505050565b63ffffffff8116600090815260ca602052604090205460609061194390613676565b600080612c118661242d565b6040517f81d2ea9500000000000000000000000000000000000000000000000000000000815290915073ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e16906381d2ea9590612c8e90899085908a908a908a9060040161592a565b602060405180830381865afa158015612cab573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ca5919061598a565b805160209091012090565b81516000906020840161182b64ffffffffff85168284613694565b6000611943612d257fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000084166136f7565b6133f8565b6000611940612d258484613728565b6000612d667fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008316613738565b9050612d937fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008216613795565b6000612dc07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000083166138a3565b9050612dcc85856138d0565b8114612e04576040517f7932f29b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b366000612e1187876138e0565b91509150612e248462ffffff19166138f0565b612e2e83836133e8565b14612e65576040517fccfad01800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b612e907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000851661391d565b612e9a83836133bf565b14612ed1576040517f02f14b4400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b50505050505050565b6000612f36816020612f0d7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008616613738565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000016919061394a565b9050612f7784848080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250612ccf92505050565b8114610b3e576040517f7185cf6b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000817f0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e73ffffffffffffffffffffffffffffffffffffffff1663134fbb4f6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561301d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613041919061598a565b1492915050565b6000613058602d602984866158b8565b613061916159a3565b60e01c9392505050565b7f00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b6473ffffffffffffffffffffffffffffffffffffffff166314b157ab8484857f00000000000000000000000000000000000000000000000000000000000003e8866040516020016130de91815260200190565b6040516020818303038152906040526040518663ffffffff1660e01b815260040161310d9594939291906159e9565b600060405180830381600087803b15801561312757600080fd5b505af1158015612ed1573d6000803e3d6000fd5b80156114125760006131596131508585613b09565b87908790613b18565b905073ffffffffffffffffffffffffffffffffffffffff81166131fe576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f4162737472616374506f73744469737061746368486f6f6b3a206e6f2072656660448201527f756e6420616464726573730000000000000000000000000000000000000000006064820152608401610b29565b611b3a73ffffffffffffffffffffffffffffffffffffffff821683613b6a565b600054610100900460ff166132b5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610b29565b611512613cc4565b60008181526002830160205260408120548190806132ec576132df8585613d64565b9250600091506123279050565b600192509050612327565b6060600061330483613d70565b90508067ffffffffffffffff81111561331f5761331f614c98565b604051908082528060200260200182016040528015613348578160200160208202803683370190505b50915060005b818110156123d8576133608482613d7b565b60001c83828151811061337557613375615425565b602090810291909101015260010161334e565b60606133998263ffffffff16613d87565b6040516020016133a99190615a1e565b6040516020818303038152906040529050919050565b60008281836133cf82602061589f565b60ff16926133df939291906158b8565b61194091615a63565b6000826020836133cf828061589f565b600073ffffffffffffffffffffffffffffffffffffffff82111561349d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f5479706543617374733a2062797465733332546f41646472657373206f76657260448201527f666c6f77000000000000000000000000000000000000000000000000000000006064820152608401610b29565b5090565b60006119437f000000000000000000000000000000000000000000000000000000000000000183615ace565b60006119408383613e45565b611b5373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad616333084613e62565b610d2b73ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad6168383613f3e565b6000806135688761242d565b90507f0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e73ffffffffffffffffffffffffffffffffffffffff166310b83dc08789848989896040518763ffffffff1660e01b81526004016135cc95949392919061592a565b60206040518083038185885af11580156135ea573d6000803e3d6000fd5b50505050506040513d601f19601f8201168201806040525081019061360f919061598a565b979650505050505050565b600080613628868686613f94565b9050600183600281111561363e5761363e61551b565b14801561365b57506000848061365657613656615a9f565b868809115b1561182b57610ca560018261554a565b610b3e8383836140be565b606061194360008333604051806020016040528060008152506140db565b6000806136a1838561554a565b90506040518111156136b1575060005b806000036136e2577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000009150506115eb565b5050606092831b9190911790911b1760181b90565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008316604c602061394a565b60006133df604d602d84866158b8565b6000611943609461375b81601886901c6bffffffffffffffffffffffff16615b09565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000851691906bffffffffffffffffffffffff166000614110565b6137c07fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000082166141a6565b613826576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f4d616c666f726d6564206d6573736167650000000000000000000000000000006044820152606401610b29565b60e4601882901c6bffffffffffffffffffffffff161015611b53576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f496e76616c6964206275726e206d6573736167653a20746f6f2073686f7274006044820152606401610b29565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000083166141e3565b60006133df6029600984866158b8565b36600061232283604d81876158b8565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008316614214565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000008316614245565b60008160ff1660000361395f575060006115eb565b6139778460181c6bffffffffffffffffffffffff1690565b6bffffffffffffffffffffffff1661399260ff84168561554a565b11156139f15761245f6139b38560781c6bffffffffffffffffffffffff1690565b6bffffffffffffffffffffffff166139d98660181c6bffffffffffffffffffffffff1690565b6bffffffffffffffffffffffff16858560ff16614276565b60208260ff161115613a85576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603a60248201527f54797065644d656d566965772f696e646578202d20417474656d70746564207460448201527f6f20696e646578206d6f7265207468616e2033322062797465730000000000006064820152608401610b29565b600882026000613aa38660781c6bffffffffffffffffffffffff1690565b6bffffffffffffffffffffffff16905060007f80000000000000000000000000000000000000000000000000000000000000007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff84011d91909501511695945050505050565b6000611940612d2584846138d0565b6000613b266042601461589f565b60ff16831015613b375750806115eb565b83604284613b4682601461589f565b60ff1692613b56939291906158b8565b613b5f91615b2e565b60601c949350505050565b80471015613bd4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e63650000006044820152606401610b29565b60008273ffffffffffffffffffffffffffffffffffffffff168260405160006040518083038185875af1925050503d8060008114613c2e576040519150601f19603f3d011682016040523d82523d6000602084013e613c33565b606091505b50509050806118a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d617920686176652072657665727465640000000000006064820152608401610b29565b600054610100900460ff16613d5b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e670000000000000000000000000000000000000000006064820152608401610b29565b61151233612504565b600061194083836142e4565b6000611943826142fc565b60006119408383614306565b60606000613d9483614330565b600101905060008167ffffffffffffffff811115613db457613db4614c98565b6040519080825280601f01601f191660200182016040528015613dde576020820181803683370190505b5090508181016020015b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff017f3031323334353637383961626364656600000000000000000000000000000000600a86061a8153600a8504945084613de857509392505050565b600081815260028301602052604081208190556119408383614412565b60405173ffffffffffffffffffffffffffffffffffffffff80851660248301528316604482015260648101829052610b3e9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261441e565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526118a59084907fa9059cbb0000000000000000000000000000000000000000000000000000000090606401613ebc565b600080807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff85870985870292508281108382030391505080600003613fec57838281613fe257613fe2615a9f565b04925050506115eb565b808411614055576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601560248201527f4d6174683a206d756c446976206f766572666c6f7700000000000000000000006044820152606401610b29565b60008486880960026001871981018816978890046003810283188082028403028082028403028082028403028082028403028082028403029081029092039091026000889003889004909101858311909403939093029303949094049190911702949350505050565b60008281526002840160205260408120829055611139848461452d565b60606001858585856040516020016140f7959493929190615b74565b6040516020818303038152906040529050949350505050565b60008061412b8660781c6bffffffffffffffffffffffff1690565b6bffffffffffffffffffffffff16905061414486614539565b8461414f878461554a565b614159919061554a565b1115614188577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000915050611139565b614192858261554a565b9050610ca58364ffffffffff168286613694565b60006141b28260d81c90565b64ffffffffff1664ffffffffff036141cc57506000919050565b60006141d783614539565b60405110159392505050565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000083166064602061394a565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000831660446020614581565b60006119437fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000083166024602061394a565b60606000614283866145b1565b9150506000614291866145b1565b915050600061429f866145b1565b91505060006142ad866145b1565b915050838383836040516020016142c79493929190615bf9565b604051602081830303815290604052945050505050949350505050565b60008181526001830160205260408120541515611940565b6000611943825490565b600082600001828154811061431d5761431d615425565b9060005260206000200154905092915050565b6000807a184f03e93ff9f4daa797ed6e38ed64bf6a1f0100000000000000008310614379577a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000830492506040015b6d04ee2d6d415b85acef810000000083106143a5576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc1000083106143c357662386f26fc10000830492506010015b6305f5e10083106143db576305f5e100830492506008015b61271083106143ef57612710830492506004015b60648310614401576064830492506002015b600a83106119435760010192915050565b6000611940838361469b565b6000614480826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166147959092919063ffffffff16565b90508051600014806144a15750808060200190518101906144a191906154a6565b6118a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610b29565b600061194083836147a4565b60006145538260181c6bffffffffffffffffffffffff1690565b61456b8360781c6bffffffffffffffffffffffff1690565b016bffffffffffffffffffffffff169050919050565b600061458e826020615d36565b614599906008615d4f565b60ff166145a785858561394a565b901c949350505050565b600080601f5b600f8160ff1611156146245760006145d0826008615d4f565b60ff1685901c90506145e1816147f3565b61ffff16841793508160ff166010146145fc57601084901b93505b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff016145b7565b50600f5b60ff8160ff161015614695576000614641826008615d4f565b60ff1685901c9050614652816147f3565b61ffff16831792508160ff1660001461466d57601083901b92505b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01614628565b50915091565b600081815260018301602052604081205480156147845760006146bf6001836157c4565b85549091506000906146d3906001906157c4565b90508181146147385760008660000182815481106146f3576146f3615425565b906000526020600020015490508087600001848154811061471657614716615425565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061474957614749615d6b565b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050611943565b6000915050611943565b5092915050565b60606111398484600085614825565b60008181526001830160205260408120546147eb57508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155611943565b506000611943565b600061480560048360ff16901c614933565b60ff1661ffff919091161760081b61481c82614933565b60ff1617919050565b6060824710156148b7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610b29565b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516148e09190615d9a565b60006040518083038185875af1925050503d806000811461491d576040519150601f19603f3d011682016040523d82523d6000602084013e614922565b606091505b509150915061360f8783838761498f565b6040805180820190915260108082527f30313233343536373839616263646566000000000000000000000000000000006020830152600091600f8416918290811061498057614980615425565b016020015160f81c9392505050565b60608315614a25578251600003614a1e5773ffffffffffffffffffffffffffffffffffffffff85163b614a1e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610b29565b5081611139565b6111398383815115614a3a5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2991906152bb565b828054828255906000526020600020908101928215614ab4579160200282015b82811115614ab45782518290614aa49082615dfe565b5091602001919060010190614a8e565b5061349d9291505b8082111561349d576000614ad08282614ad9565b50600101614abc565b508054614ae5906154c8565b6000825580601f10614af5575050565b601f016020900490600052602060002090810190611b5391905b8082111561349d5760008155600101614b0f565b60008083601f840112614b3557600080fd5b50813567ffffffffffffffff811115614b4d57600080fd5b60208301915083602082850101111561232757600080fd5b60008060008060408587031215614b7b57600080fd5b843567ffffffffffffffff80821115614b9357600080fd5b614b9f88838901614b23565b90965094506020870135915080821115614bb857600080fd5b50614bc587828801614b23565b95989497509550505050565b73ffffffffffffffffffffffffffffffffffffffff81168114611b5357600080fd5b600060208284031215614c0557600080fd5b81356115eb81614bd1565b803563ffffffff81168114614c2457600080fd5b919050565b600080600080600060808688031215614c4157600080fd5b614c4a86614c10565b945060208601359350614c5f60408701614c10565b9250606086013567ffffffffffffffff811115614c7b57600080fd5b614c8788828901614b23565b969995985093965092949392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040805190810167ffffffffffffffff81118282101715614cea57614cea614c98565b60405290565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715614d3757614d37614c98565b604052919050565b600067ffffffffffffffff821115614d5957614d59614c98565b5060051b60200190565b60006020808385031215614d7657600080fd5b823567ffffffffffffffff811115614d8d57600080fd5b8301601f81018513614d9e57600080fd5b8035614db1614dac82614d3f565b614cf0565b81815260069190911b82018301908381019087831115614dd057600080fd5b928401925b8284101561360f5760408489031215614dee5760008081fd5b614df6614cc7565b614dff85614c10565b8152614e0c868601614c10565b8187015282526040939093019290840190614dd5565b600067ffffffffffffffff831115614e3c57614e3c614c98565b614e6d60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f86011601614cf0565b9050828152838383011115614e8157600080fd5b828260208301376000602084830101529392505050565b600082601f830112614ea957600080fd5b81356020614eb9614dac83614d3f565b82815260059290921b84018101918181019086841115614ed857600080fd5b8286015b84811015614f2d57803567ffffffffffffffff811115614efc5760008081fd5b8701603f81018913614f0e5760008081fd5b614f1f898683013560408401614e22565b845250918301918301614edc565b509695505050505050565b600080600060608486031215614f4d57600080fd5b8335614f5881614bd1565b92506020840135614f6881614bd1565b9150604084013567ffffffffffffffff811115614f8457600080fd5b614f9086828701614e98565b9150509250925092565b600060208284031215614fac57600080fd5b61194082614c10565b60005b83811015614fd0578181015183820152602001614fb8565b50506000910152565b60008151808452614ff1816020860160208601614fb5565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600060208083016020845280855180835260408601915060408160051b87010192506020870160005b82811015615098577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0888603018452615086858351614fd9565b9450928501929085019060010161504c565b5092979650505050505050565b6020808252825182820181905260009190848201906040850190845b818110156150e357835163ffffffff16835292840192918401916001016150c1565b50909695505050505050565b6000806040838503121561510257600080fd5b61510b83614c10565b946020939093013593505050565b6000806000806060858703121561512f57600080fd5b61513885614c10565b935060208501359250604085013567ffffffffffffffff81111561515b57600080fd5b614bc587828801614b23565b60006020828403121561517957600080fd5b813567ffffffffffffffff81111561519057600080fd5b61113984828501614e98565b60008083601f8401126151ae57600080fd5b50813567ffffffffffffffff8111156151c657600080fd5b6020830191508360208260051b850101111561232757600080fd5b600080602083850312156151f457600080fd5b823567ffffffffffffffff81111561520b57600080fd5b6152178582860161519c565b90969095509350505050565b60008060006060848603121561523857600080fd5b61524184614c10565b95602085013595506040909401359392505050565b602080825282518282018190526000919060409081850190868401855b828110156152ae578151805173ffffffffffffffffffffffffffffffffffffffff168552860151868501529284019290850190600101615273565b5091979650505050505050565b6020815260006119406020830184614fd9565b600080602083850312156152e157600080fd5b823567ffffffffffffffff808211156152f957600080fd5b818501915085601f83011261530d57600080fd5b81358181111561531c57600080fd5b8660208260061b850101111561533157600080fd5b60209290920196919550909350505050565b6000806020838503121561535657600080fd5b823567ffffffffffffffff81111561536d57600080fd5b61521785828601614b23565b60006020828403121561538b57600080fd5b5035919050565b600080600080604085870312156153a857600080fd5b843567ffffffffffffffff808211156153c057600080fd5b6153cc8883890161519c565b909650945060208701359150808211156153e557600080fd5b50614bc58782880161519c565b6000806040838503121561540557600080fd5b61540e83614c10565b915061541c60208401614c10565b90509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600063ffffffff80831681810361549c5761549c615454565b6001019392505050565b6000602082840312156154b857600080fd5b815180151581146115eb57600080fd5b600181811c908216806154dc57607f821691505b602082108103615515577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b8082018082111561194357611943615454565b8183528181602085013750600060208284010152600060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b600060a0820173ffffffffffffffffffffffffffffffffffffffff89168352602060a08185015281895480845260c0860191506005935060c08160051b87010160008c8152848120815b848110156156bf577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff408a850301865282825461562b816154c8565b80875260018281168015615646576001811461567d576156a8565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0084168c8a01528b8315158e1b8a010194506156a8565b8688528b8820885b848110156156a05781548b82018f0152908301908d01615685565b8a018d019550505b50988a0198929650505091909101906001016155f0565b50505086810360408801526156d4818c614fd9565b94505050505061570860608401877fffffffff00000000000000000000000000000000000000000000000000000000169052565b8281036080840152611f2181858761555d565b600082601f83011261572c57600080fd5b61194083833560208501614e22565b6000806040838503121561574e57600080fd5b823567ffffffffffffffff8082111561576657600080fd5b6157728683870161571b565b9350602085013591508082111561578857600080fd5b506157958582860161571b565b9150509250929050565b6040815260006157b26040830185614fd9565b828103602084015261182b8185614fd9565b8181038181111561194357611943615454565b600060208083850312156157ea57600080fd5b825167ffffffffffffffff81111561580157600080fd5b8301601f8101851361581257600080fd5b8051615820614dac82614d3f565b81815260069190911b8201830190838101908783111561583f57600080fd5b928401925b8284101561360f576040848903121561585d5760008081fd5b615865614cc7565b845161587081614bd1565b81528486015186820152825260409093019290840190615844565b60208152600061113960208301848661555d565b60ff818116838216019081111561194357611943615454565b600080858511156158c857600080fd5b838611156158d557600080fd5b5050820193919092039150565b7fffff00000000000000000000000000000000000000000000000000000000000081358181169160028510156159225780818660020360031b1b83161692505b505092915050565b63ffffffff8616815284602082015260a06040820152600061594f60a0830186614fd9565b82810360608401526159618186614fd9565b91505073ffffffffffffffffffffffffffffffffffffffff831660808301529695505050505050565b60006020828403121561599c57600080fd5b5051919050565b7fffffffff0000000000000000000000000000000000000000000000000000000081358181169160048510156159225760049490940360031b84901b1690921692915050565b600063ffffffff808816835286602084015285604084015280851660608401525060a0608083015261360f60a0830184614fd9565b7f4e6f20726f7574657220656e726f6c6c656420666f7220646f6d61696e3a2000815260008251615a5681601f850160208701614fb5565b91909101601f0192915050565b80356020831015611943577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff602084900360031b1b1692915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b600082615b04577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b6bffffffffffffffffffffffff82811682821603908082111561478e5761478e615454565b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000081358181169160148510156159225760149490940360031b84901b1690921692915050565b7fffff0000000000000000000000000000000000000000000000000000000000008660f01b1681528460028201528360228201527fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008360601b16604282015260008251615be8816056850160208701614fb5565b919091016056019695505050505050565b7f54797065644d656d566965772f696e646578202d204f76657272616e2074686581527f20766965772e20536c696365206973206174203078000000000000000000000060208201527fffffffffffff000000000000000000000000000000000000000000000000000060d086811b821660358401527f2077697468206c656e6774682030780000000000000000000000000000000000603b840181905286821b8316604a8501527f2e20417474656d7074656420746f20696e646578206174206f6666736574203060508501527f7800000000000000000000000000000000000000000000000000000000000000607085015285821b83166071850152607784015283901b1660868201527f2e00000000000000000000000000000000000000000000000000000000000000608c8201526000608d8201610ca5565b60ff828116828216039081111561194357611943615454565b60ff818116838216029081169081811461478e5761478e615454565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b60008251615dac818460208701614fb5565b9190910192915050565b601f8211156118a5576000816000526020600020601f850160051c81016020861015615ddf5750805b601f850160051c820191505b81811015611b3a57828155600101615deb565b815167ffffffffffffffff811115615e1857615e18614c98565b615e2c81615e2684546154c8565b84615db6565b602080601f831160018114615e7f5760008415615e495750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b178555611b3a565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b82811015615ecc57888601518255948401946001909101908401615ead565b5085821015615f0857878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b0190555056fea2646970667358221220c83b6758e9bac7e4b3273dbfa9dba7a73c181542685426eeded98150643e7a3864736f6c63430008160033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad60000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b6400000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003e8
-----Decoded View---------------
Arg [0] : _erc20 (address): 0x078D782b760474a361dDA0AF3839290b0EF57AD6
Arg [1] : _mailbox (address): 0x3a464f746D23Ab22155710f44dB16dcA53e0775E
Arg [2] : _messageTransmitter (address): 0x81D40F21F12A8F0E3252Bccb954D722d4c464B64
Arg [3] : _tokenMessenger (address): 0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d
Arg [4] : _maxFeeBps (uint256): 1
Arg [5] : _minFinalityThreshold (uint32): 1000
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000078d782b760474a361dda0af3839290b0ef57ad6
Arg [1] : 0000000000000000000000003a464f746d23ab22155710f44db16dca53e0775e
Arg [2] : 00000000000000000000000081d40f21f12a8f0e3252bccb954d722d4c464b64
Arg [3] : 00000000000000000000000028b5a0e9c621a5badaa536219b3a228c8168cf5d
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 00000000000000000000000000000000000000000000000000000000000003e8
Loading...
Loading
Loading...
Loading
Loading...
Loading
0x8dadbDE67eD0589d90cdE3C940045F10092AcC11
Net Worth in USD
$0.00
Net Worth in ETH
0
Multichain Portfolio | 35 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.