Overview
ETH Balance
0.063299618624989143 ETH
Eth Value
$206.62 (@ $3,264.19/ETH)Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 123,623 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Receive Tokens | 21463326 | 25 mins ago | IN | 0 ETH | 0.0008596 | ||||
Swap And Bridge | 21463028 | 1 hr ago | IN | 0.00816244 ETH | 0.00095821 | ||||
Swap And Bridge | 21463005 | 1 hr ago | IN | 0.00049684 ETH | 0.00084376 | ||||
Receive Tokens | 21462978 | 1 hr ago | IN | 0 ETH | 0.0007715 | ||||
Receive Tokens | 21462948 | 1 hr ago | IN | 0 ETH | 0.00099585 | ||||
Receive Tokens | 21462657 | 2 hrs ago | IN | 0 ETH | 0.00070818 | ||||
Swap And Bridge | 21462564 | 2 hrs ago | IN | 0.00023362 ETH | 0.00138988 | ||||
Receive Tokens | 21462514 | 3 hrs ago | IN | 0 ETH | 0.00172582 | ||||
Receive Tokens | 21462513 | 3 hrs ago | IN | 0 ETH | 0.00157389 | ||||
Receive Tokens | 21462479 | 3 hrs ago | IN | 0 ETH | 0.00149679 | ||||
Receive Tokens | 21462437 | 3 hrs ago | IN | 0 ETH | 0.00125536 | ||||
Receive Tokens | 21462431 | 3 hrs ago | IN | 0 ETH | 0.00126033 | ||||
Receive Tokens | 21462425 | 3 hrs ago | IN | 0 ETH | 0.00112079 | ||||
Receive Tokens | 21462424 | 3 hrs ago | IN | 0 ETH | 0.0011636 | ||||
Receive Tokens | 21462423 | 3 hrs ago | IN | 0 ETH | 0.0009425 | ||||
Receive Tokens | 21462422 | 3 hrs ago | IN | 0 ETH | 0.00090151 | ||||
Receive Tokens | 21462420 | 3 hrs ago | IN | 0 ETH | 0.00093269 | ||||
Receive Tokens | 21462419 | 3 hrs ago | IN | 0 ETH | 0.00095579 | ||||
Receive Tokens | 21462418 | 3 hrs ago | IN | 0 ETH | 0.00091064 | ||||
Swap And Bridge | 21462412 | 3 hrs ago | IN | 0.00816244 ETH | 0.00118137 | ||||
Receive Tokens | 21462372 | 3 hrs ago | IN | 0 ETH | 0.0008286 | ||||
Receive Tokens | 21462348 | 3 hrs ago | IN | 0 ETH | 0.00076942 | ||||
Receive Tokens | 21462344 | 3 hrs ago | IN | 0 ETH | 0.00084538 | ||||
Receive Tokens | 21462343 | 3 hrs ago | IN | 0 ETH | 0.00088377 | ||||
Receive Tokens | 21462342 | 3 hrs ago | IN | 0 ETH | 0.00079198 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
21463390 | 12 mins ago | 0.00006258 ETH | ||||
21463367 | 17 mins ago | 0.00000965 ETH | ||||
21463301 | 30 mins ago | 0.0000456 ETH | ||||
21463171 | 56 mins ago | 0.00014401 ETH | ||||
21463171 | 56 mins ago | 0.0006459 ETH | ||||
21463028 | 1 hr ago | 0.00079137 ETH | ||||
21463005 | 1 hr ago | 0.00014401 ETH | ||||
21462960 | 1 hr ago | 0.00006258 ETH | ||||
21462942 | 1 hr ago | 0.00006258 ETH | ||||
21462849 | 2 hrs ago | 0.00006258 ETH | ||||
21462828 | 2 hrs ago | 0.00006258 ETH | ||||
21462650 | 2 hrs ago | 0.00006258 ETH | ||||
21462603 | 2 hrs ago | 0.00000295 ETH | ||||
21462564 | 2 hrs ago | 0.00012437 ETH | ||||
21462412 | 3 hrs ago | 0.00079137 ETH | ||||
21462322 | 3 hrs ago | 0.00079137 ETH | ||||
21462306 | 3 hrs ago | 0.00006258 ETH | ||||
21462291 | 3 hrs ago | 0.00014401 ETH | ||||
21462239 | 4 hrs ago | 0.00079137 ETH | ||||
21462218 | 4 hrs ago | 0.00014401 ETH | ||||
21462186 | 4 hrs ago | 0.00079137 ETH | ||||
21462091 | 4 hrs ago | 0.00079137 ETH | ||||
21462087 | 4 hrs ago | 0.0000456 ETH | ||||
21462017 | 4 hrs ago | 0.00014401 ETH | ||||
21461942 | 5 hrs ago | 0.00006258 ETH |
Loading...
Loading
Contract Name:
Bridge
Compiler Version
v0.8.18+commit.87f61d96
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IBridge, MessengerProtocol} from "./interfaces/IBridge.sol"; import {Router} from "./Router.sol"; import {Messenger} from "./Messenger.sol"; import {MessengerGateway} from "./MessengerGateway.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; import {GasUsage} from "./GasUsage.sol"; import {WormholeMessenger} from "./WormholeMessenger.sol"; import {HashUtils} from "./libraries/HashUtils.sol"; /** * @title Bridge * @dev A contract with functions to facilitate bridging tokens across different blockchains. */ contract Bridge is GasUsage, Router, MessengerGateway, IBridge { using SafeERC20 for IERC20; using HashUtils for bytes32; uint public immutable override chainId; mapping(bytes32 messageHash => uint isProcessed) public override processedMessages; mapping(bytes32 messageHash => uint isSent) public override sentMessages; // Info about bridges on other chains mapping(uint chainId => bytes32 bridgeAddress) public override otherBridges; // Info about tokens on other chains mapping(uint chainId => mapping(bytes32 tokenAddress => bool isSupported)) public override otherBridgeTokens; /** * @dev Emitted when tokens are sent on the source blockchain. */ event TokensSent( uint amount, bytes32 recipient, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger ); /** * @dev Emitted when the tokens are received on the destination blockchain. */ event TokensReceived(uint amount, bytes32 recipient, uint nonce, MessengerProtocol messenger, bytes32 message); /** * @dev Emitted when this contract receives the bridging fee. */ event ReceiveFee(uint bridgeTransactionCost, uint messageTransactionCost); /** * @dev Emitted when this contract charged the sender with the tokens for the bridging fee. */ event BridgingFeeFromTokens(uint gas); /** * @dev Emitted when the contract receives native tokens (e.g. Ether on the Ethereum network) from the admin to * supply the gas for bridging. */ event Received(address sender, uint amount); constructor( uint chainId_, uint chainPrecision_, Messenger allbridgeMessenger_, WormholeMessenger wormholeMessenger_, IGasOracle gasOracle_ ) Router(chainPrecision_) MessengerGateway(allbridgeMessenger_, wormholeMessenger_) GasUsage(gasOracle_) { chainId = chainId_; } /** * @notice Initiates a swap and bridge process of a given token for a token on another blockchain. * @dev This function is used to initiate a cross-chain transfer. The specified amount of token is first transferred * to the pool on the current chain, and then an event `TokensSent` is emitted to signal that tokens have been sent * on the source chain. See the function `receiveTokens`. * The bridging fee required for the cross-chain transfer can be paid in two ways: * - by sending the required amount of native gas token along with the transaction * (See `getTransactionCost` in the `GasUsage` contract and `getMessageCost` in the `MessengerGateway` contract). * - by setting the parameter `feeTokenAmount` with the bridging fee amount in the source tokens * (See the function `getBridgingCostInTokens`). * @param token The token to be swapped. * @param amount The amount of tokens to be swapped (including `feeTokenAmount`). * @param destinationChainId The ID of the destination chain. * @param receiveToken The token to receive in exchange for the swapped token. * @param nonce An identifier that is used to ensure that each transfer is unique and can only be processed once. * @param messenger The chosen way of delivering the message across chains. * @param feeTokenAmount The amount of tokens to be deducted from the transferred amount as a bridging fee. * */ function swapAndBridge( bytes32 token, uint amount, bytes32 recipient, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint feeTokenAmount ) external payable override whenCanSwap { require(amount > feeTokenAmount, "Bridge: amount too low for fee"); require(recipient != 0, "Bridge: bridge to the zero address"); uint bridgingFee = msg.value + _convertBridgingFeeInTokensToNativeToken(msg.sender, token, feeTokenAmount); uint amountAfterFee = amount - feeTokenAmount; uint vUsdAmount = _sendAndSwapToVUsd(token, msg.sender, amountAfterFee); _sendTokens(vUsdAmount, recipient, destinationChainId, receiveToken, nonce, messenger, bridgingFee); } /** * @notice Completes the bridging process by sending the tokens on the destination chain to the recipient. * @dev This function is called only after a bridging has been initiated by a user * through the `swapAndBridge` function on the source chain. * @param amount The amount of tokens being bridged. * @param recipient The recipient address for the bridged tokens. * @param sourceChainId The ID of the source chain. * @param receiveToken The address of the token being received. * @param nonce A unique nonce for the bridging transaction. * @param messenger The protocol used to relay the message. * @param receiveAmountMin The minimum amount of receiveToken required to be received. */ function receiveTokens( uint amount, bytes32 recipient, uint sourceChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint receiveAmountMin ) external payable override whenCanSwap { require(otherBridges[sourceChainId] != bytes32(0), "Bridge: source not registered"); bytes32 messageWithSender = this .hashMessage(amount, recipient, sourceChainId, chainId, receiveToken, nonce, messenger) .hashWithSender(otherBridges[sourceChainId]); require(processedMessages[messageWithSender] == 0, "Bridge: message processed"); // mark the transfer as received on the destination chain processedMessages[messageWithSender] = 1; // check if tokens has been sent on the source chain require(this.hasReceivedMessage(messageWithSender, messenger), "Bridge: no message"); uint receiveAmount = _receiveAndSwapFromVUsd( receiveToken, address(uint160(uint(recipient))), amount, receiveAmountMin ); // pass extra gas to the recipient if (msg.value > 0) { // ignore if passing extra gas failed // solc-ignore-next-line unused-call-retval payable(address(uint160(uint(recipient)))).call{value: msg.value}(""); } emit TokensReceived(receiveAmount, recipient, nonce, messenger, messageWithSender); } /** * @notice Allows the admin to add new supported chain destination. * @dev Registers the address of a bridge deployed on a different chain. * @param chainId_ The chain ID of the bridge to register. * @param bridgeAddress The address of the bridge contract to register. */ function registerBridge(uint chainId_, bytes32 bridgeAddress) external override onlyOwner { otherBridges[chainId_] = bridgeAddress; } /** * @notice Allows the admin to add a new supported destination token. * @dev Adds the address of a token on another chain to the list of supported tokens for the specified chain. * @param chainId_ The chain ID where the token is deployed. * @param tokenAddress The address of the token to add as a supported token. */ function addBridgeToken(uint chainId_, bytes32 tokenAddress) external override onlyOwner { otherBridgeTokens[chainId_][tokenAddress] = true; } /** * @notice Allows the admin to remove support for a destination token. * @dev Removes the address of a token on another chain from the list of supported tokens for the specified chain. * @param chainId_ The chain ID where the token is deployed. * @param tokenAddress The address of the token to remove from the list of supported tokens. */ function removeBridgeToken(uint chainId_, bytes32 tokenAddress) external override onlyOwner { otherBridgeTokens[chainId_][tokenAddress] = false; } /** * @notice Allows the admin to withdraw the bridging fee collected in native tokens. */ function withdrawGasTokens(uint amount) external override onlyOwner { payable(msg.sender).transfer(amount); } /** * @notice Allows the admin to withdraw the bridging fee collected in tokens. * @param token The address of the token contract. */ function withdrawBridgingFeeInTokens(IERC20 token) external onlyOwner { uint toWithdraw = token.balanceOf(address(this)); if (toWithdraw > 0) { token.safeTransfer(msg.sender, toWithdraw); } } /** * @dev Calculates the amount of bridging fee nominated in a given token, which includes: * - the gas cost of making the receive transaction on the destination chain, * - the gas cost of sending the message to the destination chain using the specified messenger protocol. * @param destinationChainId The ID of the destination chain. * @param messenger The chosen way of delivering the message across chains. * @param tokenAddress The address of the token contract on the source chain. * @return The total price of bridging, with the precision according to the token's `decimals()` value. */ function getBridgingCostInTokens( uint destinationChainId, MessengerProtocol messenger, address tokenAddress ) external view override returns (uint) { return gasOracle.getTransactionGasCostInUSD( destinationChainId, gasUsage[destinationChainId] + getMessageGasUsage(destinationChainId, messenger) ) / fromGasOracleScalingFactor[tokenAddress]; } /** * @dev Produces a hash of transfer parameters, which is used as a message to the bridge on the destination chain * to notify that the tokens on the source chain has been sent. * @param amount The amount of tokens being transferred. * @param recipient The address of the recipient on the destination chain. * @param sourceChainId The ID of the source chain. * @param destinationChainId The ID of the destination chain. * @param receiveToken The token being received on the destination chain. * @param nonce The unique nonce. * @param messenger The chosen way of delivering the message across chains. */ function hashMessage( uint amount, bytes32 recipient, uint sourceChainId, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger ) external pure override returns (bytes32) { return keccak256(abi.encodePacked(amount, recipient, sourceChainId, receiveToken, nonce, messenger)) .replaceChainBytes(uint8(sourceChainId), uint8(destinationChainId)); } function _sendTokens( uint amount, bytes32 recipient, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint bridgingFee ) internal { require(destinationChainId != chainId, "Bridge: wrong destination chain"); require(otherBridgeTokens[destinationChainId][receiveToken], "Bridge: unknown chain or token"); bytes32 message = this.hashMessage( amount, recipient, chainId, destinationChainId, receiveToken, nonce, messenger ); require(sentMessages[message] == 0, "Bridge: tokens already sent"); // mark the transfer as sent on the source chain sentMessages[message] = 1; uint bridgeTransactionCost = this.getTransactionCost(destinationChainId); uint messageTransactionCost = _sendMessage(message, messenger); emit ReceiveFee(bridgeTransactionCost, messageTransactionCost); unchecked { require(bridgingFee >= bridgeTransactionCost + messageTransactionCost, "Bridge: not enough fee"); } emit TokensSent(amount, recipient, destinationChainId, receiveToken, nonce, messenger); } /** * @dev Charges the bridging fee in tokens and calculates the amount of native tokens that correspond * to the charged fee using the current exchange rate. * @param user The address of the user who is paying the bridging fee * @param tokenAddress The address of the token used to pay the bridging fee * @param feeTokenAmount The amount of tokens to pay as the bridging fee * @return bridging fee amount in the native tokens (e.g. in wei for Ethereum) */ function _convertBridgingFeeInTokensToNativeToken( address user, bytes32 tokenAddress, uint feeTokenAmount ) internal returns (uint) { if (feeTokenAmount == 0) return 0; address tokenAddress_ = address(uint160(uint(tokenAddress))); IERC20 token = IERC20(tokenAddress_); token.safeTransferFrom(user, address(this), feeTokenAmount); uint fee = (bridgingFeeConversionScalingFactor[tokenAddress_] * feeTokenAmount) / gasOracle.price(chainId); emit BridgingFeeFromTokens(fee); return fee; } fallback() external payable { revert("Unsupported"); } receive() external payable { emit Received(msg.sender, msg.value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.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 Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _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 anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing 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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.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]. * * 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 ERC20 is Context, IERC20, IERC20Metadata { 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}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _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 value {ERC20} uses, unless this function is * 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 {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-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 v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @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.6.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.8.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/draft-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; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } 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)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } 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"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } 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"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.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 * ==== * * [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://diligence.consensys.net/posts/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.5.11/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 v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.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) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 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 10, 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 * 8) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; /** * @title GasOracle * @dev A contract that provides gas price and native token USD price data on other blockchains. */ contract GasOracle is Ownable, IGasOracle { struct ChainData { // price of the chain's native token in USD uint128 price; // price of a gas unit in the chain's native token with precision according to the const ORACLE_PRECISION uint128 gasPrice; } uint private constant ORACLE_PRECISION = 18; uint private constant ORACLE_SCALING_FACTOR = 10 ** ORACLE_PRECISION; // number to divide by to change precision from gas oracle price precision to chain precision uint private immutable fromOracleToChainScalingFactor; mapping(uint chainId => ChainData) public override chainData; // current chain ID uint public immutable override chainId; constructor(uint chainId_, uint chainPrecision) { chainId = chainId_; fromOracleToChainScalingFactor = 10 ** (ORACLE_PRECISION - chainPrecision); } /** * @notice Sets the chain data for a given chain ID. * @param chainId_ The ID of the given chain to set data for. * @param price_ The price of the given chain's native token in USD. * @param gasPrice The price of a gas unit in the given chain's native token (with precision according to the const * `ORACLE_PRECISION`). */ function setChainData(uint chainId_, uint128 price_, uint128 gasPrice) external override onlyOwner { chainData[chainId_].price = price_; chainData[chainId_].gasPrice = gasPrice; } /** * @notice Sets only the price for a given chain ID. * @param chainId_ The ID of the given chain to set the price for. * @param price_ The price of the given chain's native token in USD. */ function setPrice(uint chainId_, uint128 price_) external override onlyOwner { chainData[chainId_].price = price_; } /** * @notice Sets only the gas price for a given chain ID. * @param chainId_ The ID of the given chain to set the gas price for. * @param gasPrice The price of a gas unit in the given chain's native token (with precision according to the const * `ORACLE_PRECISION`). */ function setGasPrice(uint chainId_, uint128 gasPrice) external override onlyOwner { chainData[chainId_].gasPrice = gasPrice; } /** * @notice Calculates the gas cost of a transaction on another chain in the current chain's native token. * @param otherChainId The ID of the chain for which to get the gas cost. * @param gasAmount The amount of gas used in a transaction. * @return The gas cost of a transaction in the current chain's native token */ function getTransactionGasCostInNativeToken( uint otherChainId, uint gasAmount ) external view override returns (uint) { return (chainData[otherChainId].gasPrice * gasAmount * chainData[otherChainId].price) / chainData[chainId].price / fromOracleToChainScalingFactor; } /** * @notice Calculates the gas cost of a transaction on another chain in USD. * @param otherChainId The ID of the chain for which to get the gas cost. * @param gasAmount The amount of gas used in a transaction. * @return The gas cost of a transaction in USD with precision of `ORACLE_PRECISION` */ function getTransactionGasCostInUSD(uint otherChainId, uint gasAmount) external view override returns (uint) { return (chainData[otherChainId].gasPrice * gasAmount * chainData[otherChainId].price) / ORACLE_SCALING_FACTOR; } /** * @notice Get the cross-rate between the two chains' native tokens. * @param otherChainId The ID of the other chain to get the cross-rate for. */ function crossRate(uint otherChainId) external view override returns (uint) { return (chainData[otherChainId].price * ORACLE_SCALING_FACTOR) / chainData[chainId].price; } /** * @notice Get the price of a given chain's native token in USD. * @param chainId_ The ID of the given chain to get the price. * @return the price of the given chain's native token in USD with precision of const ORACLE_PRECISION */ function price(uint chainId_) external view override returns (uint) { return chainData[chainId_].price; } fallback() external payable { revert("Unsupported"); } receive() external payable { revert("Unsupported"); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; /** * @dev Contract module which allows children to store typical gas usage of a certain transaction on another chain. */ abstract contract GasUsage is Ownable { IGasOracle internal gasOracle; mapping(uint chainId => uint amount) public gasUsage; constructor(IGasOracle gasOracle_) { gasOracle = gasOracle_; } /** * @dev Sets the amount of gas used for a transaction on a given chain. * @param chainId The ID of the chain. * @param gasAmount The amount of gas used on the chain. */ function setGasUsage(uint chainId, uint gasAmount) external onlyOwner { gasUsage[chainId] = gasAmount; } /** * @dev Sets the Gas Oracle contract address. * @param gasOracle_ The address of the Gas Oracle contract. */ function setGasOracle(IGasOracle gasOracle_) external onlyOwner { gasOracle = gasOracle_; } /** * @notice Get the gas cost of a transaction on another chain in the current chain's native token. * @param chainId The ID of the chain for which to get the gas cost. * @return The calculated gas cost of the transaction in the current chain's native token */ function getTransactionCost(uint chainId) external view returns (uint) { unchecked { return gasOracle.getTransactionGasCostInNativeToken(chainId, gasUsage[chainId]); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; enum MessengerProtocol { None, Allbridge, Wormhole, LayerZero } interface IBridge { function chainId() external view returns (uint); function processedMessages(bytes32) external view returns (uint); function sentMessages(bytes32) external view returns (uint); function otherBridges(uint) external view returns (bytes32); function otherBridgeTokens(uint, bytes32) external view returns (bool); function getBridgingCostInTokens( uint destinationChainId, MessengerProtocol messenger, address tokenAddress ) external view returns (uint); function hashMessage( uint amount, bytes32 recipient, uint sourceChainId, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger ) external pure returns (bytes32); function receiveTokens( uint amount, bytes32 recipient, uint sourceChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint receiveAmountMin ) external payable; function withdrawGasTokens(uint amount) external; function registerBridge(uint chainId, bytes32 bridgeAddress) external; function addBridgeToken(uint chainId, bytes32 tokenAddress) external; function removeBridgeToken(uint chainId, bytes32 tokenAddress) external; function swapAndBridge( bytes32 token, uint amount, bytes32 recipient, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint feeTokenAmount ) external payable; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; interface IGasOracle { function chainData(uint chainId) external view returns (uint128 price, uint128 gasPrice); function chainId() external view returns (uint); function crossRate(uint otherChainId) external view returns (uint); function getTransactionGasCostInNativeToken(uint otherChainId, uint256 gasAmount) external view returns (uint); function getTransactionGasCostInUSD(uint otherChainId, uint256 gasAmount) external view returns (uint); function price(uint chainId) external view returns (uint); function setChainData(uint chainId, uint128 price, uint128 gasPrice) external; function setGasPrice(uint chainId, uint128 gasPrice) external; function setPrice(uint chainId, uint128 price) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; interface IMessenger { function sentMessagesBlock(bytes32 message) external view returns (uint); function receivedMessages(bytes32 message) external view returns (uint); function sendMessage(bytes32 message) external payable; function receiveMessage(bytes32 message, uint v1v2, bytes32 r1, bytes32 s1, bytes32 r2, bytes32 s2) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {MessengerProtocol} from "./IBridge.sol"; interface IRouter { function canSwap() external view returns (uint8); function swap(uint amount, bytes32 token, bytes32 receiveToken, address recipient, uint receiveAmountMin) external; }
// contracts/Messages.sol // SPDX-License-Identifier: Apache 2 pragma solidity ^0.8.18; interface Structs { struct Provider { uint16 chainId; uint16 governanceChainId; bytes32 governanceContract; } struct GuardianSet { address[] keys; uint32 expirationTime; } struct Signature { bytes32 r; bytes32 s; uint8 v; uint8 guardianIndex; } struct VM { uint8 version; uint32 timestamp; uint32 nonce; uint16 emitterChainId; bytes32 emitterAddress; uint64 sequence; uint8 consistencyLevel; bytes payload; uint32 guardianSetIndex; Signature[] signatures; bytes32 hash; } } interface IWormhole is Structs { event LogMessagePublished( address indexed sender, uint64 sequence, uint32 nonce, bytes payload, uint8 consistencyLevel ); function publishMessage( uint32 nonce, bytes memory payload, uint8 consistencyLevel ) external payable returns (uint64 sequence); function parseAndVerifyVM( bytes calldata encodedVM ) external view returns (Structs.VM memory vm, bool valid, string memory reason); function verifyVM(Structs.VM memory vm) external view returns (bool valid, string memory reason); function verifySignatures( bytes32 hash, Structs.Signature[] memory signatures, Structs.GuardianSet memory guardianSet ) external pure returns (bool valid, string memory reason); function parseVM(bytes memory encodedVM) external pure returns (Structs.VM memory vm); function getGuardianSet(uint32 index) external view returns (Structs.GuardianSet memory); function getCurrentGuardianSetIndex() external view returns (uint32); function getGuardianSetExpiry() external view returns (uint32); function governanceActionIsConsumed(bytes32 hash) external view returns (bool); function isInitialized(address impl) external view returns (bool); function chainId() external view returns (uint16); function governanceChainId() external view returns (uint16); function governanceContract() external view returns (bytes32); function messageFee() external view returns (uint); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; library HashUtils { function replaceChainBytes( bytes32 data, uint8 sourceChainId, uint8 destinationChainId ) internal pure returns (bytes32 result) { assembly { mstore(0x00, data) mstore8(0x00, sourceChainId) mstore8(0x01, destinationChainId) result := mload(0x0) } } function hashWithSender(bytes32 message, bytes32 sender) internal pure returns (bytes32 result) { assembly { mstore(0x00, message) mstore(0x20, sender) result := or( and( message, 0xffff000000000000000000000000000000000000000000000000000000000000 // First 2 bytes ), and( keccak256(0x00, 0x40), 0x0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Last 30 bytes ) ) } } function hashWithSenderAddress(bytes32 message, address sender) internal pure returns (bytes32 result) { assembly { mstore(0x00, message) mstore(0x20, sender) result := or( and( message, 0xffff000000000000000000000000000000000000000000000000000000000000 // First 2 bytes ), and( keccak256(0x00, 0x40), 0x0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Last 30 bytes ) ) } } function hashed(bytes32 message) internal pure returns (bytes32 result) { assembly { mstore(0x00, message) result := keccak256(0x00, 0x20) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; import {IMessenger} from "./interfaces/IMessenger.sol"; import {GasUsage} from "./GasUsage.sol"; import {HashUtils} from "./libraries/HashUtils.sol"; /** * @dev This contract implements the Allbridge messenger cross-chain communication protocol. */ contract Messenger is Ownable, GasUsage, IMessenger { using HashUtils for bytes32; // current chain ID uint public immutable chainId; // supported destination chain IDs bytes32 public otherChainIds; // the primary account that is responsible for validation that a message has been sent on the source chain address private primaryValidator; // the secondary accounts that are responsible for validation that a message has been sent on the source chain mapping(address => bool) private secondaryValidators; mapping(bytes32 messageHash => uint blockNumber) public override sentMessagesBlock; mapping(bytes32 messageHash => uint isReceived) public override receivedMessages; event MessageSent(bytes32 indexed message); event MessageReceived(bytes32 indexed message); /** * @dev Emitted when the contract receives native gas tokens (e.g. Ether on the Ethereum network). */ event Received(address, uint); /** * @dev Emitted when the mapping of secondary validators is updated. */ event SecondaryValidatorsSet(address[] oldValidators, address[] newValidators); constructor( uint chainId_, bytes32 otherChainIds_, IGasOracle gasOracle_, address primaryValidator_, address[] memory validators ) GasUsage(gasOracle_) { chainId = chainId_; otherChainIds = otherChainIds_; primaryValidator = primaryValidator_; uint length = validators.length; for (uint index; index < length; ) { secondaryValidators[validators[index]] = true; unchecked { index++; } } } /** * @notice Sends a message to another chain. * @dev Emits a {MessageSent} event, which signals to the off-chain messaging service to invoke the `receiveMessage` * function on the destination chain to deliver the message. * * Requirements: * * - the first byte of the message must be the current chain ID. * - the second byte of the message must be the destination chain ID. * - the same message cannot be sent second time. * - messaging fee must be payed. (See `getTransactionCost` of the `GasUsage` contract). * @param message The message to be sent to the destination chain. */ function sendMessage(bytes32 message) external payable override { require(uint8(message[0]) == chainId, "Messenger: wrong chainId"); require(otherChainIds[uint8(message[1])] != 0, "Messenger: wrong destination"); bytes32 messageWithSender = message.hashWithSenderAddress(msg.sender); require(sentMessagesBlock[messageWithSender] == 0, "Messenger: has message"); sentMessagesBlock[messageWithSender] = block.number; require(msg.value >= this.getTransactionCost(uint8(message[1])), "Messenger: not enough fee"); emit MessageSent(messageWithSender); } /** * @notice Delivers a message to the destination chain. * @dev Emits an {MessageReceived} event indicating the message has been delivered. * * Requirements: * * - a valid signature of the primary validator. * - a valid signature of one of the secondary validators. * - the second byte of the message must be the current chain ID. */ function receiveMessage( bytes32 message, uint v1v2, bytes32 r1, bytes32 s1, bytes32 r2, bytes32 s2 ) external override { bytes32 hashedMessage = message.hashed(); require(ecrecover(hashedMessage, uint8(v1v2 >> 8), r1, s1) == primaryValidator, "Messenger: invalid primary"); require(secondaryValidators[ecrecover(hashedMessage, uint8(v1v2), r2, s2)], "Messenger: invalid secondary"); require(uint8(message[1]) == chainId, "Messenger: wrong chainId"); receivedMessages[message] = 1; emit MessageReceived(message); } /** * @dev Allows the admin to withdraw the messaging fee collected in native gas tokens. */ function withdrawGasTokens(uint amount) external onlyOwner { payable(msg.sender).transfer(amount); } /** * @dev Allows the admin to set the primary validator address. */ function setPrimaryValidator(address value) external onlyOwner { primaryValidator = value; } /** * @dev Allows the admin to set the addresses of secondary validators. */ function setSecondaryValidators(address[] memory oldValidators, address[] memory newValidators) external onlyOwner { uint length = oldValidators.length; uint index; for (; index < length; ) { secondaryValidators[oldValidators[index]] = false; unchecked { index++; } } length = newValidators.length; index = 0; for (; index < length; ) { secondaryValidators[newValidators[index]] = true; unchecked { index++; } } emit SecondaryValidatorsSet(oldValidators, newValidators); } /** * @dev Allows the admin to update a list of supported destination chain IDs * @param value Each byte of the `value` parameter represents whether a chain ID with such index is supported * as a valid message destination. */ function setOtherChainIds(bytes32 value) external onlyOwner { otherChainIds = value; } fallback() external payable { revert("Unsupported"); } receive() external payable { emit Received(msg.sender, msg.value); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; import {Messenger} from "./Messenger.sol"; import {MessengerProtocol} from "./interfaces/IBridge.sol"; import {WormholeMessenger} from "./WormholeMessenger.sol"; /** * @dev This abstract contract provides functions for cross-chain communication and supports different messaging * protocols. */ abstract contract MessengerGateway is Ownable { Messenger private allbridgeMessenger; WormholeMessenger private wormholeMessenger; constructor(Messenger allbridgeMessenger_, WormholeMessenger wormholeMessenger_) { allbridgeMessenger = allbridgeMessenger_; wormholeMessenger = wormholeMessenger_; } /** * @dev Sets the Allbridge Messenger contract address. * @param allbridgeMessenger_ The address of the Messenger contract. */ function setAllbridgeMessenger(Messenger allbridgeMessenger_) external onlyOwner { allbridgeMessenger = allbridgeMessenger_; } /** * @dev Sets the Wormhole Messenger contract address. * @param wormholeMessenger_ The address of the WormholeMessenger contract. */ function setWormholeMessenger(WormholeMessenger wormholeMessenger_) external onlyOwner { wormholeMessenger = wormholeMessenger_; } /** * @notice Get the gas cost of a messaging transaction on another chain in the current chain's native token. * @param chainId The ID of the chain where to send the message. * @param protocol The messenger used to send the message. * @return The calculated gas cost of the messaging transaction in the current chain's native token. */ function getMessageCost(uint chainId, MessengerProtocol protocol) external view returns (uint) { if (protocol == MessengerProtocol.Allbridge) { return allbridgeMessenger.getTransactionCost(chainId); } else if (protocol == MessengerProtocol.Wormhole) { return wormholeMessenger.getTransactionCost(chainId); } return 0; } /** * @notice Get the amount of gas a messaging transaction uses on a given chain. * @param chainId The ID of the chain where to send the message. * @param protocol The messenger used to send the message. * @return The amount of gas a messaging transaction uses. */ function getMessageGasUsage(uint chainId, MessengerProtocol protocol) public view returns (uint) { if (protocol == MessengerProtocol.Allbridge) { return allbridgeMessenger.gasUsage(chainId); } else if (protocol == MessengerProtocol.Wormhole) { return wormholeMessenger.gasUsage(chainId); } return 0; } /** * @notice Checks whether a given message has been received via the specified messenger protocol. * @param message The message to check. * @param protocol The messenger used to send the message. * @return A boolean indicating whether the message has been received. */ function hasReceivedMessage(bytes32 message, MessengerProtocol protocol) external view returns (bool) { if (protocol == MessengerProtocol.Allbridge) { return allbridgeMessenger.receivedMessages(message) != 0; } else if (protocol == MessengerProtocol.Wormhole) { return wormholeMessenger.receivedMessages(message) != 0; } else { revert("Not implemented"); } } /** * @notice Checks whether a given message has been sent. * @param message The message to check. * @return A boolean indicating whether the message has been sent. */ function hasSentMessage(bytes32 message) external view returns (bool) { return allbridgeMessenger.sentMessagesBlock(message) != 0 || wormholeMessenger.sentMessages(message) != 0; } function _sendMessage(bytes32 message, MessengerProtocol protocol) internal returns (uint messageCost) { if (protocol == MessengerProtocol.Allbridge) { messageCost = allbridgeMessenger.getTransactionCost(uint8(message[1])); allbridgeMessenger.sendMessage{value: messageCost}(message); } else if (protocol == MessengerProtocol.Wormhole) { messageCost = wormholeMessenger.getTransactionCost(uint8(message[1])); wormholeMessenger.sendMessage{value: messageCost}(message); } else { revert("Not implemented"); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol"; import {RewardManager} from "./RewardManager.sol"; /** * 4AD - D = 4A(x + y) - (D³ / 4xy) * X - is value of real stable token * Y - is value of virtual usd */ contract Pool is RewardManager { using SafeERC20 for ERC20; uint private constant SYSTEM_PRECISION = 3; int private constant PP = 1e4; // Price Precision uint private constant MAX_TOKEN_BALANCE = 2 ** 40; // Max possible token balance /** * @dev Gas optimization: both the 'feeShareBP' and 'router' fields are used during the 'swapFromVUsd', 'swapToVUsd' * operations and can occupy the same slot. */ uint16 public feeShareBP; address public router; uint public tokenBalance; uint public vUsdBalance; uint public balanceRatioMinBP; uint public reserves; uint public immutable a; uint public d; uint private immutable tokenAmountReduce; uint private immutable tokenAmountIncrease; // can restrict deposit or withdraw operations address private stopAuthority; // is deposit operation allowed uint public canDeposit = 1; // is withdraw operation allowed uint public canWithdraw = 1; event SwappedToVUsd(address sender, address token, uint amount, uint vUsdAmount, uint fee); event SwappedFromVUsd(address recipient, address token, uint vUsdAmount, uint amount, uint fee); constructor( address router_, uint a_, ERC20 token_, uint16 feeShareBP_, uint balanceRatioMinBP_, string memory lpName, string memory lpSymbol ) RewardManager(token_, lpName, lpSymbol) { a = a_; router = router_; stopAuthority = owner(); feeShareBP = feeShareBP_; balanceRatioMinBP = balanceRatioMinBP_; uint decimals = token_.decimals(); tokenAmountReduce = decimals > SYSTEM_PRECISION ? 10 ** (decimals - SYSTEM_PRECISION) : 0; tokenAmountIncrease = decimals < SYSTEM_PRECISION ? 10 ** (SYSTEM_PRECISION - decimals) : 0; } /** * @dev Throws if called by any account other than the router. */ modifier onlyRouter() { require(router == msg.sender, "Pool: is not router"); _; } /** * @dev Throws if called by any account other than the stopAuthority. */ modifier onlyStopAuthority() { require(stopAuthority == msg.sender, "Pool: is not stopAuthority"); _; } /** * @dev Modifier to prevent function from disbalancing the pool over a threshold defined by `balanceRatioMinBP` */ modifier validateBalanceRatio() { _; if (tokenBalance > vUsdBalance) { require((vUsdBalance * BP) / tokenBalance >= balanceRatioMinBP, "Pool: low vUSD balance"); } else if (tokenBalance < vUsdBalance) { require((tokenBalance * BP) / vUsdBalance >= balanceRatioMinBP, "Pool: low token balance"); } } /** * @dev Modifier to make a function callable only when the deposit is allowed. */ modifier whenCanDeposit() { require(canDeposit == 1, "Pool: deposit prohibited"); _; } /** * @dev Modifier to make a function callable only when the withdraw is allowed. */ modifier whenCanWithdraw() { require(canWithdraw == 1, "Pool: withdraw prohibited"); _; } /** * @dev Calculates the price and deposit token according to the amount and price, then adds the same amount to the X * and to the Y * @param amount The deposited amount */ function deposit(uint amount) external whenCanDeposit { uint oldD = d; uint amountSP = _toSystemPrecision(amount); require(amountSP > 0, "Pool: too little"); token.safeTransferFrom(msg.sender, address(this), amount); // Add deposited amount to reserves reserves += amountSP; uint oldBalance = (tokenBalance + vUsdBalance); if (oldD == 0 || oldBalance == 0) { // Split balance equally on the first deposit uint halfAmount = amountSP >> 1; tokenBalance += halfAmount; vUsdBalance += halfAmount; } else { // Add amount proportionally to each pool tokenBalance += (amountSP * tokenBalance) / oldBalance; vUsdBalance += (amountSP * vUsdBalance) / oldBalance; } _updateD(); // Deposit as many LP tokens as the D increase _depositLp(msg.sender, d - oldD); require(tokenBalance < MAX_TOKEN_BALANCE, "Pool: too much"); } /* * @dev Subtracts X and Y for that amount, calculates current price and withdraw the token to the user according to * the price * @param amount The deposited amount */ function withdraw(uint amountLp) external whenCanWithdraw { uint oldD = d; _withdrawLp(msg.sender, amountLp); // Always withdraw tokens in amount equal to amountLp // Withdraw proportionally from token and vUsd balance uint oldBalance = (tokenBalance + vUsdBalance); tokenBalance -= (amountLp * tokenBalance) / oldBalance; vUsdBalance -= (amountLp * vUsdBalance) / oldBalance; require(tokenBalance + vUsdBalance < oldBalance, "Pool: zero changes"); // Check if there is enough funds in reserve to withdraw require(amountLp <= reserves, "Pool: reserves"); // Adjust reserves by withdraw amount reserves -= amountLp; // Update D and transfer tokens to the sender _updateD(); require(d < oldD, "Pool: zero D changes"); token.safeTransfer(msg.sender, _fromSystemPrecision(amountLp)); } /** * @notice Calculates new virtual USD value from the given amount of tokens. * @dev Calculates new Y according to new X. * NOTICE: Prior to calling this the router must transfer tokens from the user to the pool. * @param amount The amount of tokens to swap. * @param zeroFee When true it allows to swap without incurring any fees. It is intended for use with service * accounts. * @return returns the difference between the old and the new value of vUsdBalance */ function swapToVUsd( address user, uint amount, bool zeroFee ) external onlyRouter validateBalanceRatio returns (uint) { uint result; // 0 by default uint fee; if (amount > 0) { if (!zeroFee) { fee = (amount * feeShareBP) / BP; } uint amountIn = _toSystemPrecision(amount - fee); // Incorporate rounding dust into the fee fee = amount - _fromSystemPrecision(amountIn); // Adjust token and reserve balances after the fee is applied tokenBalance += amountIn; reserves += amountIn; uint vUsdNewAmount = this.getY(tokenBalance); if (vUsdBalance > vUsdNewAmount) { result = vUsdBalance - vUsdNewAmount; } vUsdBalance = vUsdNewAmount; _addRewards(fee); } emit SwappedToVUsd(user, address(token), amount, result, fee); return result; } /** * @notice Calculates the amount of tokens from the given virtual USD value, and transfers it to the user. * @dev Calculates new X according to new Y. * @param user The address of the recipient. * @param amount The amount of vUSD to swap. * @param receiveAmountMin The minimum amount of tokens required to be received during the swap, otherwise the * transaction reverts. * @param zeroFee When true it allows to swap without incurring any fees. It is intended for use with service * accounts. * @return returns the difference between the old and the new value of vUsdBalance */ function swapFromVUsd( address user, uint amount, uint receiveAmountMin, bool zeroFee ) external onlyRouter validateBalanceRatio returns (uint) { uint resultSP; // 0 by default uint result; // 0 by default uint fee; if (amount > 0) { vUsdBalance += amount; uint newAmount = this.getY(vUsdBalance); if (tokenBalance > newAmount) { resultSP = tokenBalance - newAmount; result = _fromSystemPrecision(resultSP); } // Otherwise result/resultSP stay 0 // Check if there is enough funds in reserve to pay require(resultSP <= reserves, "Pool: reserves"); // Remove from reserves including fee, apply fee later reserves -= resultSP; if (!zeroFee) { fee = (result * feeShareBP) / BP; } // We can use unchecked here because feeShareBP <= BP unchecked { result -= fee; } tokenBalance = newAmount; require(result >= receiveAmountMin, "Pool: slippage"); token.safeTransfer(user, result); _addRewards(fee); } emit SwappedFromVUsd(user, address(token), amount, result, fee); return result; } /** * @dev Sets admin fee share. */ function setFeeShare(uint16 feeShareBP_) external onlyOwner { require(feeShareBP_ <= BP, "Pool: too large"); feeShareBP = feeShareBP_; } function adjustTotalLpAmount() external onlyOwner { if (d > totalSupply()) { _depositLp(owner(), d - totalSupply()); } } /** * @dev Sets the threshold over which the pool can't be disbalanced. */ function setBalanceRatioMinBP(uint balanceRatioMinBP_) external onlyOwner { require(balanceRatioMinBP_ <= BP, "Pool: too large"); balanceRatioMinBP = balanceRatioMinBP_; } /** * @dev Switches off the possibility to make deposits. */ function stopDeposit() external onlyStopAuthority { canDeposit = 0; } /** * @dev Switches on the possibility to make deposits. */ function startDeposit() external onlyOwner { canDeposit = 1; } /** * @dev Switches off the possibility to make withdrawals. */ function stopWithdraw() external onlyStopAuthority { canWithdraw = 0; } /** * @dev Switches on the possibility to make withdrawals. */ function startWithdraw() external onlyOwner { canWithdraw = 1; } /** * @dev Sets the address of the stopAuthority account. */ function setStopAuthority(address stopAuthority_) external onlyOwner { stopAuthority = stopAuthority_; } /** * @dev Sets the address of the Router contract. */ function setRouter(address router_) external onlyOwner { router = router_; } /** * @dev y = (sqrt(x(4AD³ + x (4A(D - x) - D )²)) + x (4A(D - x) - D ))/8Ax. */ function getY(uint x) external view returns (uint) { uint d_ = d; // Gas optimization uint a4 = a << 2; uint a8 = a4 << 1; // 4A(D - x) - D int part1 = int(a4) * (int(d_) - int(x)) - int(d_); // x * (4AD³ + x(part1²)) uint part2 = x * (a4 * d_ * d_ * d_ + x * uint(part1 * part1)); // (sqrt(part2) + x(part1)) / 8Ax) return SafeCast.toUint256(int(_sqrt(part2)) + int(x) * part1) / (a8 * x) + 1; // +1 to offset rounding errors } /** * @dev price = (1/2) * ((D³ + 8ADx² - 8Ax³ - 2Dx²) / (4x * sqrt(x(4AD³ + x (4A(D - x) - D )²)))) */ function getPrice() external view returns (uint) { uint x = tokenBalance; uint a8 = a << 3; uint dCubed = d * d * d; // 4A(D - x) - D int p1 = int(a << 2) * (int(d) - int(x)) - int(d); // x * 4AD³ + x(p1²) uint p2 = x * ((a << 2) * dCubed + x * uint(p1 * p1)); // D³ + 8ADx² - 8Ax³ - 2Dx² int p3 = int(dCubed) + int((a << 3) * d * x * x) - int(a8 * x * x * x) - int((d << 1) * x * x); // 1/2 * p3 / (4x * sqrt(p2)) return SafeCast.toUint256((PP >> 1) + ((PP * p3) / int((x << 2) * _sqrt(p2)))); } function _updateD() internal { uint x = tokenBalance; uint y = vUsdBalance; // a = 8 * Axy(x+y) // b = 4 * xy(4A - 1) / 3 // c = sqrt(a² + b³) // D = cbrt(a + c) + cbrt(a - c) uint xy = x * y; uint a_ = a; // Axy(x+y) uint p1 = a_ * xy * (x + y); // xy(4A - 1) / 3 uint p2 = (xy * ((a_ << 2) - 1)) / 3; // p1² + p2³ uint p3 = _sqrt((p1 * p1) + (p2 * p2 * p2)); unchecked { uint d_ = _cbrt(p1 + p3); if (p3 > p1) { d_ -= _cbrt(p3 - p1); } else { d_ += _cbrt(p1 - p3); } d = (d_ << 1); } } function _toSystemPrecision(uint amount) internal view returns (uint) { if (tokenAmountReduce > 0) { return amount / tokenAmountReduce; } else if (tokenAmountIncrease > 0) { return amount * tokenAmountIncrease; } return amount; } function _fromSystemPrecision(uint amount) internal view returns (uint) { if (tokenAmountReduce > 0) { return amount * tokenAmountReduce; } else if (tokenAmountIncrease > 0) { return amount / tokenAmountIncrease; } return amount; } function _sqrt(uint n) internal pure returns (uint) { unchecked { if (n > 0) { uint x = (n >> 1) + 1; uint y = (x + n / x) >> 1; while (x > y) { x = y; y = (x + n / x) >> 1; } return x; } return 0; } } function _cbrt(uint n) internal pure returns (uint) { unchecked { uint x = 0; for (uint y = 1 << 255; y > 0; y >>= 3) { x <<= 1; uint z = 3 * x * (x + 1) + 1; if (n / y >= z) { n -= y * z; x += 1; } } return x; } } fallback() external payable { revert("Unsupported"); } receive() external payable { revert("Unsupported"); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; contract RewardManager is Ownable, ERC20 { using SafeERC20 for ERC20; uint private constant P = 52; uint internal constant BP = 1e4; // Accumulated rewards per share, shifted left by P bits uint public accRewardPerShareP; // Reward token ERC20 public immutable token; // Info of each user reward debt mapping(address user => uint amount) public userRewardDebt; // Admin fee share (in basis points) uint public adminFeeShareBP; // Unclaimed admin fee amount uint public adminFeeAmount; event Deposit(address indexed user, uint amount); event Withdraw(address indexed user, uint amount); event RewardsClaimed(address indexed user, uint amount); constructor(ERC20 token_, string memory lpName, string memory lpSymbol) ERC20(lpName, lpSymbol) { token = token_; // Default admin fee is 20% adminFeeShareBP = BP / 5; } /** * @notice Claims pending rewards for the current staker without updating the stake balance. */ function claimRewards() external { uint userLpAmount = balanceOf(msg.sender); if (userLpAmount > 0) { uint rewards = (userLpAmount * accRewardPerShareP) >> P; uint pending = rewards - userRewardDebt[msg.sender]; if (pending > 0) { userRewardDebt[msg.sender] = rewards; token.safeTransfer(msg.sender, pending); emit RewardsClaimed(msg.sender, pending); } } } /** * @notice Sets the basis points of the admin fee share from rewards. */ function setAdminFeeShare(uint adminFeeShareBP_) external onlyOwner { require(adminFeeShareBP_ <= BP, "RewardManager: too high"); adminFeeShareBP = adminFeeShareBP_; } /** * @notice Allows the admin to claim the collected admin fee. */ function claimAdminFee() external onlyOwner { if (adminFeeAmount > 0) { token.safeTransfer(msg.sender, adminFeeAmount); adminFeeAmount = 0; } } /** * @notice Returns pending rewards for the staker. * @param user The address of the staker. */ function pendingReward(address user) external view returns (uint) { return ((balanceOf(user) * accRewardPerShareP) >> P) - userRewardDebt[user]; } /** * @dev Returns the number of decimals used to get user representation of LP tokens. */ function decimals() public pure override returns (uint8) { return 3; } /** * @dev Adds reward to the pool, splits admin fee share and updates the accumulated rewards per share. */ function _addRewards(uint rewardAmount) internal { if (totalSupply() > 0) { uint adminFeeRewards = (rewardAmount * adminFeeShareBP) / BP; unchecked { rewardAmount -= adminFeeRewards; } accRewardPerShareP += (rewardAmount << P) / totalSupply(); adminFeeAmount += adminFeeRewards; } } /** * @dev Deposits LP amount for the user, updates user reward debt and pays pending rewards. */ function _depositLp(address to, uint lpAmount) internal { uint pending; uint userLpAmount = balanceOf(to); // Gas optimization if (userLpAmount > 0) { pending = ((userLpAmount * accRewardPerShareP) >> P) - userRewardDebt[to]; } userLpAmount += lpAmount; _mint(to, lpAmount); userRewardDebt[to] = (userLpAmount * accRewardPerShareP) >> P; if (pending > 0) { token.safeTransfer(to, pending); emit RewardsClaimed(to, pending); } emit Deposit(to, lpAmount); } /** * @dev Withdraws LP amount for the user, updates user reward debt and pays out pending rewards. */ function _withdrawLp(address from, uint lpAmount) internal { uint userLpAmount = balanceOf(from); // Gas optimization require(userLpAmount >= lpAmount, "RewardManager: not enough amount"); uint pending; if (userLpAmount > 0) { pending = ((userLpAmount * accRewardPerShareP) >> P) - userRewardDebt[from]; } userLpAmount -= lpAmount; _burn(from, lpAmount); userRewardDebt[from] = (userLpAmount * accRewardPerShareP) >> P; if (pending > 0) { token.safeTransfer(from, pending); emit RewardsClaimed(from, pending); } emit Withdraw(from, lpAmount); } function _transfer(address, address, uint) internal pure override { revert("Unsupported"); } function _approve(address, address, uint) internal pure override { revert("Unsupported"); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IRouter} from "./interfaces/IRouter.sol"; import {MessengerProtocol} from "./interfaces/IBridge.sol"; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {Pool} from "./Pool.sol"; abstract contract Router is Ownable, IRouter { using SafeERC20 for ERC20; uint private immutable chainPrecision; uint internal constant ORACLE_PRECISION = 18; mapping(bytes32 tokenId => Pool) public pools; // precomputed values to divide by to change the precision from the Gas Oracle precision to the token precision mapping(address tokenAddress => uint scalingFactor) internal fromGasOracleScalingFactor; // precomputed values of the scaling factor required for paying the bridging fee with stable tokens mapping(address tokenAddress => uint scalingFactor) internal bridgingFeeConversionScalingFactor; // can restrict swap operations address private stopAuthority; /** * @dev The rebalancer is an account responsible for balancing the liquidity pools. It ensures that the pool is * balanced by executing zero-fee swaps when the pool is imbalanced. * * Gas optimization: both the 'rebalancer' and 'canSwap' fields are used in the 'swap' and 'swapAndBridge' * functions and can occupy the same slot. */ address private rebalancer; uint8 public override canSwap = 1; /** * @dev Emitted during the on-chain swap of tokens. */ event Swapped( address sender, address recipient, bytes32 sendToken, bytes32 receiveToken, uint sendAmount, uint receiveAmount ); constructor(uint chainPrecision_) { chainPrecision = chainPrecision_; stopAuthority = owner(); } /** * @dev Modifier to make a function callable only when the swap is allowed. */ modifier whenCanSwap() { require(canSwap == 1, "Router: swap prohibited"); _; } /** * @dev Throws if called by any account other than the stopAuthority. */ modifier onlyStopAuthority() { require(stopAuthority == msg.sender, "Router: is not stopAuthority"); _; } /** * @notice Swaps a given pair of tokens on the same blockchain. * @param amount The amount of tokens to be swapped. * @param token The token to be swapped. * @param receiveToken The token to receive in exchange for the swapped token. * @param recipient The address to receive the tokens. * @param receiveAmountMin The minimum amount of tokens required to receive during the swap. */ function swap( uint amount, bytes32 token, bytes32 receiveToken, address recipient, uint receiveAmountMin ) external override whenCanSwap { uint vUsdAmount = _sendAndSwapToVUsd(token, msg.sender, amount); uint receivedAmount = _receiveAndSwapFromVUsd(receiveToken, recipient, vUsdAmount, receiveAmountMin); emit Swapped(msg.sender, recipient, token, receiveToken, amount, receivedAmount); } /** * @notice Allows the admin to add new supported liquidity pools. * @dev Adds the address of the `Pool` contract to the list of supported liquidity pools. * @param pool The address of the `Pool` contract. * @param token The address of the token in the liquidity pool. */ function addPool(Pool pool, bytes32 token) external onlyOwner { pools[token] = pool; address tokenAddress = address(uint160(uint(token))); uint tokenDecimals = ERC20(tokenAddress).decimals(); bridgingFeeConversionScalingFactor[tokenAddress] = 10 ** (ORACLE_PRECISION - tokenDecimals + chainPrecision); fromGasOracleScalingFactor[tokenAddress] = 10 ** (ORACLE_PRECISION - tokenDecimals); } /** * @dev Switches off the possibility to make swaps. */ function stopSwap() external onlyStopAuthority { canSwap = 0; } /** * @dev Switches on the possibility to make swaps. */ function startSwap() external onlyOwner { canSwap = 1; } /** * @dev Allows the admin to set the address of the stopAuthority. */ function setStopAuthority(address stopAuthority_) external onlyOwner { stopAuthority = stopAuthority_; } /** * @dev Allows the admin to set the address of the rebalancer. */ function setRebalancer(address rebalancer_) external onlyOwner { rebalancer = rebalancer_; } function _receiveAndSwapFromVUsd( bytes32 token, address recipient, uint vUsdAmount, uint receiveAmountMin ) internal returns (uint) { Pool tokenPool = pools[token]; require(address(tokenPool) != address(0), "Router: no receive pool"); return tokenPool.swapFromVUsd(recipient, vUsdAmount, receiveAmountMin, recipient == rebalancer); } function _sendAndSwapToVUsd(bytes32 token, address user, uint amount) internal virtual returns (uint) { Pool pool = pools[token]; require(address(pool) != address(0), "Router: no pool"); ERC20(address(uint160(uint(token)))).safeTransferFrom(user, address(pool), amount); return pool.swapToVUsd(user, amount, user == rebalancer); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {IBridge, MessengerProtocol} from "../interfaces/IBridge.sol"; import {Router} from "../Router.sol"; contract TestBridgeForSwap is IBridge, Router { uint public chainId; mapping(bytes32 messageHash => uint isProcessed) public override processedMessages; mapping(bytes32 messageHash => uint isSent) public override sentMessages; // Info about bridges on other chains mapping(uint chainId => bytes32 bridgeAddress) public override otherBridges; // Info about tokens on other chains mapping(uint chainId => mapping(bytes32 tokenAddress => bool isSupported)) public override otherBridgeTokens; event vUsdSent(uint amount); constructor() Router(18) {} function swapAndBridge( bytes32 token, uint amount, bytes32 recipient, uint destinationChainId, bytes32 receiveToken, uint nonce, MessengerProtocol messenger, uint feeTokenAmount ) external payable override {} function receiveTokens( uint amount, bytes32, uint, bytes32 receiveToken, uint, MessengerProtocol, uint receiveAmountMin ) external payable override {} function withdrawGasTokens(uint amount) external override onlyOwner {} function registerBridge(uint chainId_, bytes32 bridgeAddress_) external override onlyOwner {} function addBridgeToken(uint chainId_, bytes32 tokenAddress_) external override onlyOwner {} function removeBridgeToken(uint chainId_, bytes32 tokenAddress_) external override onlyOwner {} function getBridgingCostInTokens( uint, MessengerProtocol, address ) external pure override returns (uint) { return 0; } function hashMessage( uint, bytes32, uint, uint, bytes32, uint, MessengerProtocol ) external pure override returns (bytes32) { return 0; } function _sendAndSwapToVUsd(bytes32 token, address user, uint amount) internal override returns (uint) { uint vUsdAmount = super._sendAndSwapToVUsd(token, user, amount); emit vUsdSent(vUsdAmount); return vUsdAmount; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {Pool} from "../Pool.sol"; import {RewardManager} from "../RewardManager.sol"; contract TestPool is Pool { constructor( address router_, uint a_, ERC20 token_, uint16 feeShareBP_, uint balanceRatioMinBP_ ) Pool(router_, a_, token_, feeShareBP_, balanceRatioMinBP_, "LP", "LP") {} function setVUsdBalance(uint vUsdBalance_) public { vUsdBalance = vUsdBalance_; } function setTokenBalance(uint tokenBalance_) public { tokenBalance = tokenBalance_; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {RewardManager} from "../RewardManager.sol"; contract TestPoolForRewards is RewardManager { // solhint-disable-next-line no-empty-blocks constructor(ERC20 token) RewardManager(token, "LP", "LP") {} function deposit(uint amount) external { _depositLp(msg.sender, amount); } function withdraw(uint amount) external { _withdrawLp(msg.sender, amount); } function addRewards(uint amount) external { _addRewards(amount); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; import {IGasOracle} from "./interfaces/IGasOracle.sol"; import {IMessenger} from "./interfaces/IMessenger.sol"; import {IWormhole} from "./interfaces/IWormhole.sol"; import {GasUsage} from "./GasUsage.sol"; import {GasOracle} from "./GasOracle.sol"; import {HashUtils} from "./libraries/HashUtils.sol"; contract WormholeMessenger is Ownable, GasUsage { using HashUtils for bytes32; IWormhole private immutable wormhole; uint public immutable chainId; bytes32 public otherChainIds; uint32 private nonce; uint8 private commitmentLevel; mapping(uint16 chainId => bytes32 wormholeMessengerAddress) private otherWormholeMessengers; mapping(bytes32 messageHash => uint isReceived) public receivedMessages; mapping(bytes32 messageHash => uint isSent) public sentMessages; event MessageSent(bytes32 indexed message, uint64 sequence); event MessageReceived(bytes32 indexed message, uint64 sequence); event Received(address, uint); constructor( uint chainId_, bytes32 otherChainIds_, IWormhole wormhole_, uint8 commitmentLevel_, IGasOracle gasOracle_ ) GasUsage(gasOracle_) { chainId = chainId_; otherChainIds = otherChainIds_; wormhole = wormhole_; commitmentLevel = commitmentLevel_; } function sendMessage(bytes32 message) external payable { require(uint8(message[0]) == chainId, "WormholeMessenger: wrong chainId"); require(otherChainIds[uint8(message[1])] != 0, "Messenger: wrong destination"); bytes32 messageWithSender = message.hashWithSenderAddress(msg.sender); uint32 nonce_ = nonce; uint64 sequence = wormhole.publishMessage(nonce_, abi.encodePacked(messageWithSender), commitmentLevel); unchecked { nonce = nonce_ + 1; } require(sentMessages[messageWithSender] == 0, "WormholeMessenger: has message"); sentMessages[messageWithSender] = 1; emit MessageSent(messageWithSender, sequence); } function receiveMessage(bytes memory encodedMsg) external { (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole.parseAndVerifyVM(encodedMsg); require(valid, reason); require(vm.payload.length == 32, "WormholeMessenger: wrong length"); bytes32 messageWithSender = bytes32(vm.payload); require(uint8(messageWithSender[1]) == chainId, "WormholeMessenger: wrong chainId"); require(otherWormholeMessengers[vm.emitterChainId] == vm.emitterAddress, "WormholeMessenger: wrong emitter"); receivedMessages[messageWithSender] = 1; emit MessageReceived(messageWithSender, vm.sequence); } function setCommitmentLevel(uint8 value) external onlyOwner { commitmentLevel = value; } function setOtherChainIds(bytes32 value) external onlyOwner { otherChainIds = value; } function registerWormholeMessenger(uint16 chainId_, bytes32 address_) external onlyOwner { otherWormholeMessengers[chainId_] = address_; } function withdrawGasTokens(uint amount) external onlyOwner { payable(msg.sender).transfer(amount); } fallback() external payable { revert("Unsupported"); } receive() external payable { emit Received(msg.sender, msg.value); } }
{ "optimizer": { "enabled": true, "runs": 1000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"chainId_","type":"uint256"},{"internalType":"uint256","name":"chainPrecision_","type":"uint256"},{"internalType":"contract Messenger","name":"allbridgeMessenger_","type":"address"},{"internalType":"contract WormholeMessenger","name":"wormholeMessenger_","type":"address"},{"internalType":"contract IGasOracle","name":"gasOracle_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gas","type":"uint256"}],"name":"BridgingFeeFromTokens","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":false,"internalType":"uint256","name":"bridgeTransactionCost","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"messageTransactionCost","type":"uint256"}],"name":"ReceiveFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"bytes32","name":"sendToken","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"sendAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"receiveAmount","type":"uint256"}],"name":"Swapped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"recipient","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"},{"indexed":false,"internalType":"bytes32","name":"message","type":"bytes32"}],"name":"TokensReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"recipient","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"destinationChainId","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"}],"name":"TokensSent","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"uint256","name":"chainId_","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"}],"name":"addBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract Pool","name":"pool","type":"address"},{"internalType":"bytes32","name":"token","type":"bytes32"}],"name":"addPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"canSwap","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"gasUsage","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"destinationChainId","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"getBridgingCostInTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"protocol","type":"uint8"}],"name":"getMessageCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"protocol","type":"uint8"}],"name":"getMessageGasUsage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"getTransactionCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"message","type":"bytes32"},{"internalType":"enum MessengerProtocol","name":"protocol","type":"uint8"}],"name":"hasReceivedMessage","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"message","type":"bytes32"}],"name":"hasSentMessage","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint256","name":"sourceChainId","type":"uint256"},{"internalType":"uint256","name":"destinationChainId","type":"uint256"},{"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"}],"name":"hashMessage","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"}],"name":"otherBridgeTokens","outputs":[{"internalType":"bool","name":"isSupported","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"otherBridges","outputs":[{"internalType":"bytes32","name":"bridgeAddress","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"tokenId","type":"bytes32"}],"name":"pools","outputs":[{"internalType":"contract Pool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"processedMessages","outputs":[{"internalType":"uint256","name":"isProcessed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint256","name":"sourceChainId","type":"uint256"},{"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"},{"internalType":"uint256","name":"receiveAmountMin","type":"uint256"}],"name":"receiveTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId_","type":"uint256"},{"internalType":"bytes32","name":"bridgeAddress","type":"bytes32"}],"name":"registerBridge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId_","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"}],"name":"removeBridgeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"sentMessages","outputs":[{"internalType":"uint256","name":"isSent","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract Messenger","name":"allbridgeMessenger_","type":"address"}],"name":"setAllbridgeMessenger","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IGasOracle","name":"gasOracle_","type":"address"}],"name":"setGasOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"uint256","name":"gasAmount","type":"uint256"}],"name":"setGasUsage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"rebalancer_","type":"address"}],"name":"setRebalancer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stopAuthority_","type":"address"}],"name":"setStopAuthority","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract WormholeMessenger","name":"wormholeMessenger_","type":"address"}],"name":"setWormholeMessenger","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"token","type":"bytes32"},{"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"receiveAmountMin","type":"uint256"}],"name":"swap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"token","type":"bytes32"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint256","name":"destinationChainId","type":"uint256"},{"internalType":"bytes32","name":"receiveToken","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"enum MessengerProtocol","name":"messenger","type":"uint8"},{"internalType":"uint256","name":"feeTokenAmount","type":"uint256"}],"name":"swapAndBridge","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"withdrawBridgingFeeInTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawGasTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604052600436106102385760003560e01c806382e3702d11610138578063b5217bb4116100b0578063e3f04fa41161007f578063e4ce616011610064578063e4ce61601461074c578063eb5886751461076c578063f2fde38b1461078c57610277565b8063e3f04fa414610719578063e43bfe5e1461073957610277565b8063b5217bb414610699578063b633b364146106cf578063c7c56d7e146106e4578063c992b5b21461070457610277565b80639a8a059211610107578063a1f5e9cd116100ec578063a1f5e9cd14610639578063a87b815214610659578063aab651921461067957610277565b80639a8a0592146105e55780639bb557421461061957610277565b806382e3702d1461053957806388ba16ab146105665780638b9369e2146105935780638da5cb5b146105b357610277565b80633ee2594e116101cb578063685933371161019a578063715018a61161017f578063715018a6146104e4578063737dae1d146104f95780637d18330b1461051957610277565b806368593337146104a45780636cfd1553146104c457610277565b80633ee2594e146104315780634927b44c146104515780634cd480bd146104715780635fa1ebd91461048457610277565b80632d4b01b5116102075780632d4b01b5146103975780632ed1084b146103c4578063331838b2146103e457806336d6825a1461040457610277565b806310ce0516146102c45780631268cee8146102fc57806318b513081461031e5780632c48bb8d1461034c57610277565b3661027757604080513381523460208201527f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f88525874910160405180910390a1005b60405162461bcd60e51b815260206004820152600b60248201527f556e737570706f7274656400000000000000000000000000000000000000000060448201526064015b60405180910390fd5b3480156102d057600080fd5b506007546102e590600160a01b900460ff1681565b60405160ff90911681526020015b60405180910390f35b34801561030857600080fd5b5061031c6103173660046123f1565b6107ac565b005b34801561032a57600080fd5b5061033e6103393660046123f1565b6107e5565b6040519081526020016102f3565b34801561035857600080fd5b5061038761036736600461240a565b600d60209081526000928352604080842090915290825290205460ff1681565b60405190151581526020016102f3565b3480156103a357600080fd5b5061033e6103b23660046123f1565b600c6020526000908152604090205481565b3480156103d057600080fd5b5061033e6103df366004612440565b610888565b3480156103f057600080fd5b5061031c6103ff3660046124b1565b6108dd565b34801561041057600080fd5b5061033e61041f3660046123f1565b60026020526000908152604090205481565b34801561043d57600080fd5b5061031c61044c36600461240a565b6109c0565b34801561045d57600080fd5b5061031c61046c3660046124fa565b6109da565b61031c61047f366004612517565b610a04565b34801561049057600080fd5b5061031c61049f36600461240a565b610b78565b3480156104b057600080fd5b5061033e6104bf36600461257d565b610b92565b3480156104d057600080fd5b5061031c6104df3660046124fa565b610c75565b3480156104f057600080fd5b5061031c610c9f565b34801561050557600080fd5b5061033e61051436600461257d565b610cb3565b34801561052557600080fd5b5061033e6105343660046125a9565b610d49565b34801561054557600080fd5b5061033e6105543660046123f1565b600b6020526000908152604090205481565b34801561057257600080fd5b5061033e6105813660046123f1565b600a6020526000908152604090205481565b34801561059f57600080fd5b506103876105ae3660046123f1565b610e25565b3480156105bf57600080fd5b506000546001600160a01b03165b6040516001600160a01b0390911681526020016102f3565b3480156105f157600080fd5b5061033e7f000000000000000000000000000000000000000000000000000000000000000181565b34801561062557600080fd5b5061031c6106343660046124fa565b610f42565b34801561064557600080fd5b5061031c6106543660046124fa565b610f6c565b34801561066557600080fd5b5061031c6106743660046124fa565b610f96565b34801561068557600080fd5b5061031c61069436600461240a565b610fc0565b3480156106a557600080fd5b506105cd6106b43660046123f1565b6003602052600090815260409020546001600160a01b031681565b3480156106db57600080fd5b5061031c610feb565b3480156106f057600080fd5b5061031c6106ff36600461240a565b611054565b34801561071057600080fd5b5061031c611082565b34801561072557600080fd5b5061031c6107343660046124fa565b61109f565b61031c6107473660046125e9565b611147565b34801561075857600080fd5b5061038761076736600461257d565b6114ec565b34801561077857600080fd5b5061031c610787366004612645565b611610565b34801561079857600080fd5b5061031c6107a73660046124fa565b611757565b6107b46117e7565b604051339082156108fc029083906000818181858888f193505050501580156107e1573d6000803e3d6000fd5b5050565b6001546000828152600260205260408082205490517fca24994c00000000000000000000000000000000000000000000000000000000815260048101859052602481019190915290916001600160a01b03169063ca24994c90604401602060405180830381865afa15801561085e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108829190612671565b92915050565b60006108cf86868a8a8a8989896040516020016108aa969594939291906126a0565b604051602081830303815290604052805190602001206118419092919063ffffffff16565b90505b979650505050505050565b600754600160a01b900460ff166001146109395760405162461bcd60e51b815260206004820152601760248201527f526f757465723a20737761702070726f6869626974656400000000000000000060448201526064016102bb565b600061094685338861185a565b905060006109568585848661197a565b604080513381526001600160a01b0387166020820152908101889052606081018790526080810189905260a081018290529091507fe85f63622be58135a84c6e9de632115a3c471b0540a04d37a7c53a0647cd0c399060c00160405180910390a150505050505050565b6109c86117e7565b6000918252600c602052604090912055565b6109e26117e7565b600680546001600160a01b0319166001600160a01b0392909216919091179055565b600754600160a01b900460ff16600114610a605760405162461bcd60e51b815260206004820152601760248201527f526f757465723a20737761702070726f6869626974656400000000000000000060448201526064016102bb565b808711610aaf5760405162461bcd60e51b815260206004820152601e60248201527f4272696467653a20616d6f756e7420746f6f206c6f7720666f7220666565000060448201526064016102bb565b6000869003610b265760405162461bcd60e51b815260206004820152602260248201527f4272696467653a2062726964676520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016102bb565b6000610b33338a84611a8f565b610b3d9034612709565b90506000610b4b838a61271c565b90506000610b5a8b338461185a565b9050610b6b818a8a8a8a8a89611bd1565b5050505050505050505050565b610b806117e7565b60009182526002602052604090912055565b60006001826003811115610ba857610ba861268a565b03610c2257600854604051630316a26160e31b8152600481018590526001600160a01b03909116906318b51308906024015b602060405180830381865afa158015610bf7573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c1b9190612671565b9050610882565b6002826003811115610c3657610c3661268a565b03610c6c57600954604051630316a26160e31b8152600481018590526001600160a01b03909116906318b5130890602401610bda565b50600092915050565b610c7d6117e7565b600780546001600160a01b0319166001600160a01b0392909216919091179055565b610ca76117e7565b610cb16000611ef5565b565b60006001826003811115610cc957610cc961268a565b03610cff57600854604051631b6b412d60e11b8152600481018590526001600160a01b03909116906336d6825a90602401610bda565b6002826003811115610d1357610d1361268a565b03610c6c57600954604051631b6b412d60e11b8152600481018590526001600160a01b03909116906336d6825a90602401610bda565b6001600160a01b0380821660009081526004602052604081205460015491929091166358c09b8f86610d7b8188610cb3565b600089815260026020526040902054610d949190612709565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b16815260048101929092526024820152604401602060405180830381865afa158015610ded573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e119190612671565b610e1b919061272f565b90505b9392505050565b6008546040517f95b70182000000000000000000000000000000000000000000000000000000008152600481018390526000916001600160a01b0316906395b7018290602401602060405180830381865afa158015610e88573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610eac9190612671565b15158061088257506009546040517f82e3702d000000000000000000000000000000000000000000000000000000008152600481018490526001600160a01b03909116906382e3702d90602401602060405180830381865afa158015610f16573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f3a9190612671565b151592915050565b610f4a6117e7565b600980546001600160a01b0319166001600160a01b0392909216919091179055565b610f746117e7565b600880546001600160a01b0319166001600160a01b0392909216919091179055565b610f9e6117e7565b600180546001600160a01b0319166001600160a01b0392909216919091179055565b610fc86117e7565b6000918252600d602090815260408084209284529190529020805460ff19169055565b6006546001600160a01b031633146110455760405162461bcd60e51b815260206004820152601c60248201527f526f757465723a206973206e6f742073746f70417574686f726974790000000060448201526064016102bb565b6007805460ff60a01b19169055565b61105c6117e7565b6000918252600d602090815260408084209284529190529020805460ff19166001179055565b61108a6117e7565b6007805460ff60a01b1916600160a01b179055565b6110a76117e7565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526000906001600160a01b038316906370a0823190602401602060405180830381865afa158015611107573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061112b9190612671565b905080156107e1576107e16001600160a01b0383163383611f45565b600754600160a01b900460ff166001146111a35760405162461bcd60e51b815260206004820152601760248201527f526f757465723a20737761702070726f6869626974656400000000000000000060448201526064016102bb565b6000858152600c60205260409020546111fe5760405162461bcd60e51b815260206004820152601d60248201527f4272696467653a20736f75726365206e6f74207265676973746572656400000060448201526064016102bb565b6000858152600c6020526040808220549051632ed1084b60e01b81526112fe91903090632ed1084b90611261908d908d908d907f0000000000000000000000000000000000000000000000000000000000000001908e908e908e90600401612773565b602060405180830381865afa15801561127e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112a29190612671565b90600082600052816020527dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6040600020167fffff000000000000000000000000000000000000000000000000000000000000841617905092915050565b6000818152600a60205260409020549091501561135d5760405162461bcd60e51b815260206004820152601960248201527f4272696467653a206d6573736167652070726f6365737365640000000000000060448201526064016102bb565b6000818152600a60205260409081902060019055517fe4ce6160000000000000000000000000000000000000000000000000000000008152309063e4ce6160906113ad90849087906004016127b5565b602060405180830381865afa1580156113ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113ee91906127c9565b61143a5760405162461bcd60e51b815260206004820152601260248201527f4272696467653a206e6f206d657373616765000000000000000000000000000060448201526064016102bb565b600061144886898b8661197a565b905034156114a2576040516001600160a01b038916903490600081818185875af1925050503d8060008114611499576040519150601f19603f3d011682016040523d82523d6000602084013e61149e565b606091505b5050505b7fe9d840d27ab4032a839c20760fb995af8e3ad1980b9428980ca1c7e072acd87a81898787866040516114d99594939291906127eb565b60405180910390a1505050505050505050565b600060018260038111156115025761150261268a565b0361157e5760085460405163f69f815160e01b8152600481018590526001600160a01b039091169063f69f8151906024015b602060405180830381865afa158015611551573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115759190612671565b15159050610882565b60028260038111156115925761159261268a565b036115c85760095460405163f69f815160e01b8152600481018590526001600160a01b039091169063f69f815190602401611534565b60405162461bcd60e51b815260206004820152600f60248201527f4e6f7420696d706c656d656e746564000000000000000000000000000000000060448201526064016102bb565b6116186117e7565b600081815260036020908152604080832080546001600160a01b0319166001600160a01b038781169190911790915581517f313ce56700000000000000000000000000000000000000000000000000000000815291518594939185169263313ce5679260048083019391928290030181865afa15801561169c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116c0919061281d565b60ff1690507f00000000000000000000000000000000000000000000000000000000000000126116f182601261271c565b6116fb9190612709565b61170690600a612924565b6001600160a01b03831660009081526005602052604090205561172a81601261271c565b61173590600a612924565b6001600160a01b03909216600090815260046020526040902091909155505050565b61175f6117e7565b6001600160a01b0381166117db5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016102bb565b6117e481611ef5565b50565b6000546001600160a01b03163314610cb15760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016102bb565b6000836000528260005381600153505060005192915050565b6000838152600360205260408120546001600160a01b0316806118bf5760405162461bcd60e51b815260206004820152600f60248201527f526f757465723a206e6f20706f6f6c000000000000000000000000000000000060448201526064016102bb565b6118d46001600160a01b038616858386611ff3565b6007546040517f28fdb4810000000000000000000000000000000000000000000000000000000081526001600160a01b0386811660048301819052602483018790529281169092146044820152908216906328fdb481906064016020604051808303816000875af115801561194d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119719190612671565b95945050505050565b6000848152600360205260408120546001600160a01b0316806119df5760405162461bcd60e51b815260206004820152601760248201527f526f757465723a206e6f207265636569766520706f6f6c00000000000000000060448201526064016102bb565b6007546040517f2d46f63e0000000000000000000000000000000000000000000000000000000081526001600160a01b03878116600483018190526024830188905260448301879052928116909214606482015290821690632d46f63e906084016020604051808303816000875af1158015611a5f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a839190612671565b9150505b949350505050565b600081600003611aa157506000610e1e565b8280611ab86001600160a01b038216873087611ff3565b6001546040517f26a49e370000000000000000000000000000000000000000000000000000000081527f000000000000000000000000000000000000000000000000000000000000000160048201526000916001600160a01b0316906326a49e3790602401602060405180830381865afa158015611b3a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b5e9190612671565b6001600160a01b038416600090815260056020526040902054611b82908790612930565b611b8c919061272f565b90507f02a1962fff2ae0f895c1fcd8481ce39cce1e8083e752ce6f5e80d2b5366382c881604051611bbf91815260200190565b60405180910390a19695505050505050565b7f00000000000000000000000000000000000000000000000000000000000000018503611c405760405162461bcd60e51b815260206004820152601f60248201527f4272696467653a2077726f6e672064657374696e6174696f6e20636861696e0060448201526064016102bb565b6000858152600d6020908152604080832087845290915290205460ff16611ca95760405162461bcd60e51b815260206004820152601e60248201527f4272696467653a20756e6b6e6f776e20636861696e206f7220746f6b656e000060448201526064016102bb565b604051632ed1084b60e01b81526000903090632ed1084b90611cfb908b908b907f0000000000000000000000000000000000000000000000000000000000000001908c908c908c908c90600401612773565b602060405180830381865afa158015611d18573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611d3c9190612671565b6000818152600b602052604090205490915015611d9b5760405162461bcd60e51b815260206004820152601b60248201527f4272696467653a20746f6b656e7320616c72656164792073656e74000000000060448201526064016102bb565b6000818152600b60205260408082206001905551630316a26160e31b81526004810188905230906318b5130890602401602060405180830381865afa158015611de8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e0c9190612671565b90506000611e1a838661204a565b60408051848152602081018390529192507f706abb59b8db30e9e92cb7e272fbe6682712ec97e7b117d7ee3389b24bb3de21910160405180910390a1808201841015611ea85760405162461bcd60e51b815260206004820152601660248201527f4272696467653a206e6f7420656e6f756768206665650000000000000000000060448201526064016102bb565b7f9cd6008e8d4ebd34fd9d022278fec7f95d133780ecc1a0dea459fae3e96753908a8a8a8a8a8a604051611ee196959493929190612947565b60405180910390a150505050505050505050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6040516001600160a01b038316602482015260448101829052611fee9084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526121f9565b505050565b6040516001600160a01b03808516602483015283166044820152606481018290526120449085907f23b872dd0000000000000000000000000000000000000000000000000000000090608401611f8a565b50505050565b600060018260038111156120605761206061268a565b0361213c57600854604051630316a26160e31b8152600185901a60048201526001600160a01b03909116906318b5130890602401602060405180830381865afa1580156120b1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906120d59190612671565b600854604051631c25939560e31b8152600481018690529192506001600160a01b03169063e12c9ca89083906024015b6000604051808303818588803b15801561211e57600080fd5b505af1158015612132573d6000803e3d6000fd5b5050505050610882565b60028260038111156121505761215061268a565b036115c857600954604051630316a26160e31b8152600185901a60048201526001600160a01b03909116906318b5130890602401602060405180830381865afa1580156121a1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121c59190612671565b600954604051631c25939560e31b8152600481018690529192506001600160a01b03169063e12c9ca8908390602401612105565b600061224e826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166122de9092919063ffffffff16565b805190915015611fee578080602001905181019061226c91906127c9565b611fee5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016102bb565b6060610e1b848460008585600080866001600160a01b03168587604051612305919061299b565b60006040518083038185875af1925050503d8060008114612342576040519150601f19603f3d011682016040523d82523d6000602084013e612347565b606091505b50915091506108d287838387606083156123c25782516000036123bb576001600160a01b0385163b6123bb5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016102bb565b5081611a87565b611a8783838151156123d75781518083602001fd5b8060405162461bcd60e51b81526004016102bb91906129b7565b60006020828403121561240357600080fd5b5035919050565b6000806040838503121561241d57600080fd5b50508035926020909101359150565b80356004811061243b57600080fd5b919050565b600080600080600080600060e0888a03121561245b57600080fd5b873596506020880135955060408801359450606088013593506080880135925060a0880135915061248e60c0890161242c565b905092959891949750929550565b6001600160a01b03811681146117e457600080fd5b600080600080600060a086880312156124c957600080fd5b85359450602086013593506040860135925060608601356124e98161249c565b949793965091946080013592915050565b60006020828403121561250c57600080fd5b8135610e1e8161249c565b600080600080600080600080610100898b03121561253457600080fd5b883597506020890135965060408901359550606089013594506080890135935060a0890135925061256760c08a0161242c565b915060e089013590509295985092959890939650565b6000806040838503121561259057600080fd5b823591506125a06020840161242c565b90509250929050565b6000806000606084860312156125be57600080fd5b833592506125ce6020850161242c565b915060408401356125de8161249c565b809150509250925092565b600080600080600080600060e0888a03121561260457600080fd5b873596506020880135955060408801359450606088013593506080880135925061263060a0890161242c565b915060c0880135905092959891949750929550565b6000806040838503121561265857600080fd5b82356126638161249c565b946020939093013593505050565b60006020828403121561268357600080fd5b5051919050565b634e487b7160e01b600052602160045260246000fd5b8681528560208201528460408201528360608201528260808201526000600483106126db57634e487b7160e01b600052602160045260246000fd5b5060f89190911b60a082015260a10195945050505050565b634e487b7160e01b600052601160045260246000fd5b80820180821115610882576108826126f3565b81810381811115610882576108826126f3565b60008261274c57634e487b7160e01b600052601260045260246000fd5b500490565b6004811061276f57634e487b7160e01b600052602160045260246000fd5b9052565b600060e0820190508882528760208301528660408301528560608301528460808301528360a08301526127a960c0830184612751565b98975050505050505050565b82815260408101610e1e6020830184612751565b6000602082840312156127db57600080fd5b81518015158114610e1e57600080fd5b858152602081018590526040810184905260a0810161280d6060830185612751565b8260808301529695505050505050565b60006020828403121561282f57600080fd5b815160ff81168114610e1e57600080fd5b600181815b8085111561287b578160001904821115612861576128616126f3565b8085161561286e57918102915b93841c9390800290612845565b509250929050565b60008261289257506001610882565b8161289f57506000610882565b81600181146128b557600281146128bf576128db565b6001915050610882565b60ff8411156128d0576128d06126f3565b50506001821b610882565b5060208310610133831016604e8410600b84101617156128fe575081810a610882565b6129088383612840565b806000190482111561291c5761291c6126f3565b029392505050565b6000610e1e8383612883565b8082028115828204841417610882576108826126f3565b600060c0820190508782528660208301528560408301528460608301528360808301526108d260a0830184612751565b60005b8381101561299257818101518382015260200161297a565b50506000910152565b600082516129ad818460208701612977565b9190910192915050565b60208152600082518060208401526129d6816040850160208701612977565b601f01601f1916919091016040019291505056fea2646970667358221220927398be6ba13ed822ffd71f0e06604d56057496cd4aa5bfebae5e2875e63f6464736f6c63430008120033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000012000000000000000000000000203e8785b4d4312c4152d0c42ba3fa8bd79086da0000000000000000000000007f02294f065a605c8d21d9812b8d1de7e5e1da740000000000000000000000000bdf6139f2841a7856ca154d851182c52f5b96e0
-----Decoded View---------------
Arg [0] : chainId_ (uint256): 1
Arg [1] : chainPrecision_ (uint256): 18
Arg [2] : allbridgeMessenger_ (address): 0x203e8785b4d4312c4152D0c42Ba3FA8BD79086dA
Arg [3] : wormholeMessenger_ (address): 0x7f02294f065A605C8D21D9812b8d1De7E5E1da74
Arg [4] : gasOracle_ (address): 0x0BdF6139F2841A7856Ca154D851182C52F5b96e0
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [2] : 000000000000000000000000203e8785b4d4312c4152d0c42ba3fa8bd79086da
Arg [3] : 0000000000000000000000007f02294f065a605c8d21d9812b8d1de7e5e1da74
Arg [4] : 0000000000000000000000000bdf6139f2841a7856ca154d851182c52f5b96e0
Deployed Bytecode Sourcemap
747:13368:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14075:31;;;14084:10;188:74:28;;14096:9:10;293:2:28;278:18;;271:34;14075:31:10;;161:18:28;14075:31:10;;;;;;;747:13368;;13999:21;;-1:-1:-1;;;13999:21:10;;518:2:28;13999:21:10;;;500::28;557:2;537:18;;;530:30;596:13;576:18;;;569:41;627:18;;13999:21:10;;;;;;;;1538:33:17;;;;;;;;;;-1:-1:-1;1538:33:17;;;;-1:-1:-1;;;1538:33:17;;;;;;;;;828:4:28;816:17;;;798:36;;786:2;771:18;1538:33:17;;;;;;;;8849:121:10;;;;;;;;;;-1:-1:-1;8849:121:10;;;;;:::i;:::-;;:::i;:::-;;1369:201:12;;;;;;;;;;-1:-1:-1;1369:201:12;;;;;:::i;:::-;;:::i;:::-;;;1176:25:28;;;1164:2;1149:18;1369:201:12;1030:177:28;1256:108:10;;;;;;;;;;-1:-1:-1;1256:108:10;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1630:14:28;;1623:22;1605:41;;1593:2;1578:18;1256:108:10;1465:187:28;1134:75:10;;;;;;;;;;-1:-1:-1;1134:75:10;;;;;:::i;:::-;;;;;;;;;;;;;;11115:477;;;;;;;;;;-1:-1:-1;11115:477:10;;;;;:::i;:::-;;:::i;2806:462:17:-;;;;;;;;;;-1:-1:-1;2806:462:17;;;;;:::i;:::-;;:::i;386:52:12:-;;;;;;;;;;-1:-1:-1;386:52:12;;;;;:::i;:::-;;;;;;;;;;;;;;7547:145:10;;;;;;;;;;-1:-1:-1;7547:145:10;;;;;:::i;:::-;;:::i;4399:116:17:-;;;;;;;;;;-1:-1:-1;4399:116:17;;;;;:::i;:::-;;:::i;4200:803:10:-;;;;;;:::i;:::-;;:::i;721:116:12:-;;;;;;;;;;-1:-1:-1;721:116:12;;;;;:::i;:::-;;:::i;1781:379:14:-;;;;;;;;;;-1:-1:-1;1781:379:14;;;;;:::i;:::-;;:::i;4604:104:17:-;;;;;;;;;;-1:-1:-1;4604:104:17;;;;;:::i;:::-;;:::i;1831:101:0:-;;;;;;;;;;;;;:::i;2461:361:14:-;;;;;;;;;;-1:-1:-1;2461:361:14;;;;;:::i;:::-;;:::i;10004:440:10:-;;;;;;;;;;-1:-1:-1;10004:440:10;;;;;:::i;:::-;;:::i;1014:72::-;;;;;;;;;;-1:-1:-1;1014:72:10;;;;;:::i;:::-;;;;;;;;;;;;;;926:82;;;;;;;;;;-1:-1:-1;926:82:10;;;;;:::i;:::-;;;;;;;;;;;;;;3756:192:14;;;;;;;;;;-1:-1:-1;3756:192:14;;;;;:::i;:::-;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1247:7:0;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;;-1:-1:-1;;;;;5617:55:28;;;5599:74;;5587:2;5572:18;1201:85:0;5453:226:28;882:38:10;;;;;;;;;;;;;;;1267:142:14;;;;;;;;;;-1:-1:-1;1267:142:14;;;;;:::i;:::-;;:::i;969:138::-;;;;;;;;;;-1:-1:-1;969:138:14;;;;;:::i;:::-;;:::i;974:103:12:-;;;;;;;;;;-1:-1:-1;974:103:12;;;;;:::i;:::-;;:::i;8580:158:10:-;;;;;;;;;;-1:-1:-1;8580:158:10;;;;;:::i;:::-;;:::i;598:45:17:-;;;;;;;;;;-1:-1:-1;598:45:17;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;598:45:17;;;4087:75;;;;;;;;;;;;;:::i;8048:154:10:-;;;;;;;;;;-1:-1:-1;8048:154:10;;;;;:::i;:::-;;:::i;4239:68:17:-;;;;;;;;;;;;;:::i;9129:231:10:-;;;;;;;;;;-1:-1:-1;9129:231:10;;;;;:::i;:::-;;:::i;5764:1473::-;;;;;;:::i;:::-;;:::i;3128:430:14:-;;;;;;;;;;-1:-1:-1;3128:430:14;;;;;:::i;:::-;;:::i;3577:432:17:-;;;;;;;;;;-1:-1:-1;3577:432:17;;;;;:::i;:::-;;:::i;2081:198:0:-;;;;;;;;;;-1:-1:-1;2081:198:0;;;;;:::i;:::-;;:::i;8849:121:10:-;1094:13:0;:11;:13::i;:::-;8927:36:10::1;::::0;8935:10:::1;::::0;8927:36;::::1;;;::::0;8956:6;;8927:36:::1;::::0;;;8956:6;8935:10;8927:36;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;8849:121:::0;:::o;1369:201:12:-;1481:9;;1434:4;1535:17;;;:8;:17;;;;;;;1481:72;;;;;;;;8464:25:28;;;8505:18;;;8498:34;;;;1434:4:12;;-1:-1:-1;;;;;1481:9:12;;:44;;8437:18:28;;1481:72:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1474:79;1369:201;-1:-1:-1;;1369:201:12:o;11115:477:10:-;11370:7;11408:177;11543:13;11565:18;11435:6;11443:9;11454:13;11469:12;11483:5;11490:9;11418:82;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;11408:93;;;;;;:128;;:177;;;;;:::i;:::-;11389:196;;11115:477;;;;;;;;;;:::o;2806:462:17:-;2096:7;;-1:-1:-1;;;2096:7:17;;;;2107:1;2096:12;2088:48;;;;-1:-1:-1;;;2088:48:17;;9878:2:28;2088:48:17;;;9860:21:28;9917:2;9897:18;;;9890:30;9956:25;9936:18;;;9929:53;9999:18;;2088:48:17;9676:347:28;2088:48:17;2998:15:::1;3016:45;3035:5;3042:10;3054:6;3016:18;:45::i;:::-;2998:63;;3071:19;3093:78;3117:12;3131:9;3142:10;3154:16;3093:23;:78::i;:::-;3186:75;::::0;;3194:10:::1;10376:34:28::0;;-1:-1:-1;;;;;10446:15:28;;10441:2;10426:18;;10419:43;10478:18;;;10471:34;;;10536:2;10521:18;;10514:34;;;10579:3;10564:19;;10557:35;;;10623:3;10608:19;;10601:35;;;3071:100:17;;-1:-1:-1;3186:75:17::1;::::0;10302:3:28;10287:19;3186:75:17::1;;;;;;;2988:280;;2806:462:::0;;;;;:::o;7547:145:10:-;1094:13:0;:11;:13::i;:::-;7647:22:10::1;::::0;;;:12:::1;:22;::::0;;;;;:38;7547:145::o;4399:116:17:-;1094:13:0;:11;:13::i;:::-;4478::17::1;:30:::0;;-1:-1:-1;;;;;;4478:30:17::1;-1:-1:-1::0;;;;;4478:30:17;;;::::1;::::0;;;::::1;::::0;;4399:116::o;4200:803:10:-;2096:7:17;;-1:-1:-1;;;2096:7:17;;;;2107:1;2096:12;2088:48;;;;-1:-1:-1;;;2088:48:17;;9878:2:28;2088:48:17;;;9860:21:28;9917:2;9897:18;;;9890:30;9956:25;9936:18;;;9929:53;9999:18;;2088:48:17;9676:347:28;2088:48:17;4514:14:10::1;4505:6;:23;4497:66;;;::::0;-1:-1:-1;;;4497:66:10;;10849:2:28;4497:66:10::1;::::0;::::1;10831:21:28::0;10888:2;10868:18;;;10861:30;10927:32;10907:18;;;10900:60;10977:18;;4497:66:10::1;10647:354:28::0;4497:66:10::1;4594:1;4581:14:::0;;;4573:61:::1;;;::::0;-1:-1:-1;;;4573:61:10;;11208:2:28;4573:61:10::1;::::0;::::1;11190:21:28::0;11247:2;11227:18;;;11220:30;11286:34;11266:18;;;11259:62;11357:4;11337:18;;;11330:32;11379:19;;4573:61:10::1;11006:398:28::0;4573:61:10::1;4644:16;4675:75;4716:10;4728:5;4735:14;4675:40;:75::i;:::-;4663:87;::::0;:9:::1;:87;:::i;:::-;4644:106:::0;-1:-1:-1;4760:19:10::1;4782:23;4791:14:::0;4782:6;:23:::1;:::i;:::-;4760:45;;4816:15;4834:53;4853:5;4860:10;4872:14;4834:18;:53::i;:::-;4816:71;;4897:99;4909:10;4921:9;4932:18;4952:12;4966:5;4973:9;4984:11;4897;:99::i;:::-;4487:516;;;4200:803:::0;;;;;;;;:::o;721:116:12:-;1094:13:0;:11;:13::i;:::-;801:17:12::1;::::0;;;:8:::1;:17;::::0;;;;;:29;721:116::o;1781:379:14:-;1870:4;1902:27;1890:8;:39;;;;;;;;:::i;:::-;;1886:250;;1952:18;;:46;;-1:-1:-1;;;1952:46:14;;;;;1176:25:28;;;-1:-1:-1;;;;;1952:18:14;;;;:37;;1149:18:28;;1952:46:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1945:53;;;;1886:250;2031:26;2019:8;:38;;;;;;;;:::i;:::-;;2015:121;;2080:17;;:45;;-1:-1:-1;;;2080:45:14;;;;;1176:25:28;;;-1:-1:-1;;;;;2080:17:14;;;;:36;;1149:18:28;;2080:45:14;1030:177:28;2015:121:14;-1:-1:-1;2152:1:14;1781:379;;;;:::o;4604:104:17:-;1094:13:0;:11;:13::i;:::-;4677:10:17::1;:24:::0;;-1:-1:-1;;;;;;4677:24:17::1;-1:-1:-1::0;;;;;4677:24:17;;;::::1;::::0;;;::::1;::::0;;4604:104::o;1831:101:0:-;1094:13;:11;:13::i;:::-;1895:30:::1;1922:1;1895:18;:30::i;:::-;1831:101::o:0;2461:361:14:-;2552:4;2584:27;2572:8;:39;;;;;;;;:::i;:::-;;2568:230;;2634:18;;:36;;-1:-1:-1;;;2634:36:14;;;;;1176:25:28;;;-1:-1:-1;;;;;2634:18:14;;;;:27;;1149:18:28;;2634:36:14;1030:177:28;2568:230:14;2703:26;2691:8;:38;;;;;;;;:::i;:::-;;2687:111;;2752:17;;:35;;-1:-1:-1;;;2752:35:14;;;;;1176:25:28;;;-1:-1:-1;;;;;2752:17:14;;;;:26;;1149:18:28;;2752:35:14;1030:177:28;10004:440:10;-1:-1:-1;;;;;10397:40:10;;;10175:4;10397:40;;;:26;:40;;;;;;10210:9;;10175:4;;10397:40;;10210:9;:36;10264:18;10331:49;10264:18;10370:9;10331:18;:49::i;:::-;10300:28;;;;:8;:28;;;;;;:80;;;;:::i;:::-;10210:184;;;;;;;;;;;;;8464:25:28;;;;8505:18;;;8498:34;8437:18;;10210:184:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:227;;;;:::i;:::-;10191:246;;10004:440;;;;;;:::o;3756:192:14:-;3843:18;;:45;;;;;;;;1176:25:28;;;3820:4:14;;-1:-1:-1;;;;;3843:18:14;;:36;;1149:18:28;;3843:45:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;:98;;-1:-1:-1;3897:17:14;;:39;;;;;;;;1176:25:28;;;-1:-1:-1;;;;;3897:17:14;;;;:30;;1149:18:28;;3897:39:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;3836:105;3756:192;-1:-1:-1;;3756:192:14:o;1267:142::-;1094:13:0;:11;:13::i;:::-;1364:17:14::1;:38:::0;;-1:-1:-1;;;;;;1364:38:14::1;-1:-1:-1::0;;;;;1364:38:14;;;::::1;::::0;;;::::1;::::0;;1267:142::o;969:138::-;1094:13:0;:11;:13::i;:::-;1060:18:14::1;:40:::0;;-1:-1:-1;;;;;;1060:40:14::1;-1:-1:-1::0;;;;;1060:40:14;;;::::1;::::0;;;::::1;::::0;;969:138::o;974:103:12:-;1094:13:0;:11;:13::i;:::-;1048:9:12::1;:22:::0;;-1:-1:-1;;;;;;1048:22:12::1;-1:-1:-1::0;;;;;1048:22:12;;;::::1;::::0;;;::::1;::::0;;974:103::o;8580:158:10:-;1094:13:0;:11;:13::i;:::-;8726:5:10::1;8682:27:::0;;;:17:::1;:27;::::0;;;;;;;:41;;;;;;;;:49;;-1:-1:-1;;8682:49:10::1;::::0;;8580:158::o;4087:75:17:-;2297:13;;-1:-1:-1;;;;;2297:13:17;2314:10;2297:27;2289:68;;;;-1:-1:-1;;;2289:68:17;;12342:2:28;2289:68:17;;;12324:21:28;12381:2;12361:18;;;12354:30;12420;12400:18;;;12393:58;12468:18;;2289:68:17;12140:352:28;2289:68:17;4144:7:::1;:11:::0;;-1:-1:-1;;;;4144:11:17::1;::::0;;4087:75::o;8048:154:10:-;1094:13:0;:11;:13::i;:::-;8147:27:10::1;::::0;;;:17:::1;:27;::::0;;;;;;;:41;;;;;;;;:48;;-1:-1:-1;;8147:48:10::1;8191:4;8147:48;::::0;;8048:154::o;4239:68:17:-;1094:13:0;:11;:13::i;:::-;4289:7:17::1;:11:::0;;-1:-1:-1;;;;4289:11:17::1;-1:-1:-1::0;;;4289:11:17::1;::::0;;4239:68::o;9129:231:10:-;1094:13:0;:11;:13::i;:::-;9227:30:10::1;::::0;;;;9251:4:::1;9227:30;::::0;::::1;5599:74:28::0;9209:15:10::1;::::0;-1:-1:-1;;;;;9227:15:10;::::1;::::0;::::1;::::0;5572:18:28;;9227:30:10::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9209:48:::0;-1:-1:-1;9271:14:10;;9267:87:::1;;9301:42;-1:-1:-1::0;;;;;9301:18:10;::::1;9320:10;9332::::0;9301:18:::1;:42::i;5764:1473::-:0;2096:7:17;;-1:-1:-1;;;2096:7:17;;;;2107:1;2096:12;2088:48;;;;-1:-1:-1;;;2088:48:17;;9878:2:28;2088:48:17;;;9860:21:28;9917:2;9897:18;;;9890:30;9956:25;9936:18;;;9929:53;9999:18;;2088:48:17;9676:347:28;2088:48:17;6082:1:10::1;6043:27:::0;;;:12:::1;:27;::::0;;;;;6035:83:::1;;;::::0;-1:-1:-1;;;6035:83:10;;12699:2:28;6035:83:10::1;::::0;::::1;12681:21:28::0;12738:2;12718:18;;;12711:30;12777:31;12757:18;;;12750:59;12826:18;;6035:83:10::1;12497:353:28::0;6035:83:10::1;6128:25;6289:27:::0;;;:12:::1;:27;::::0;;;;;;6156:104;;-1:-1:-1;;;6156:104:10;;:161:::1;::::0;6289:27;6156:4:::1;::::0;:29:::1;::::0;:104:::1;::::0;6186:6;;6194:9;;6302:13;;6220:7:::1;::::0;6229:12;;6243:5;;6250:9;;6156:104:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:132:::0;512:14:24;574:7;568:4;561:21;608:6;602:4;595:20;899:66;872:4;866;856:21;831:169;712:66;683:7;658:155;638:376;628:386;;432:598;;;;;6156:161:10::1;6336:36;::::0;;;:17:::1;:36;::::0;;;;;6128:189;;-1:-1:-1;6336:41:10;6328:79:::1;;;::::0;-1:-1:-1;;;6328:79:10;;14212:2:28;6328:79:10::1;::::0;::::1;14194:21:28::0;14251:2;14231:18;;;14224:30;14290:27;14270:18;;;14263:55;14335:18;;6328:79:10::1;14010:349:28::0;6328:79:10::1;6483:36;::::0;;;:17:::1;:36;::::0;;;;;;6522:1:::1;6483:40:::0;;6603:53;;;;:4:::1;::::0;:23:::1;::::0;:53:::1;::::0;6501:17;;6646:9;;6603:53:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6595:84;;;::::0;-1:-1:-1;;;6595:84:10;;15148:2:28;6595:84:10::1;::::0;::::1;15130:21:28::0;15187:2;15167:18;;;15160:30;15226:20;15206:18;;;15199:48;15264:18;;6595:84:10::1;14946:342:28::0;6595:84:10::1;6690:18;6711:156;6748:12:::0;6795:9;6821:6;6841:16;6711:23:::1;:156::i;:::-;6690:177:::0;-1:-1:-1;6924:9:10::1;:13:::0;6920:219:::1;;7059:69;::::0;-1:-1:-1;;;;;7059:47:10;::::1;::::0;7114:9:::1;::::0;7083:15:::1;7059:69:::0;7083:15;7059:69;7114:9;7059:47;:69:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6920:219;7153:77;7168:13;7183:9;7194:5;7201:9;7212:17;7153:77;;;;;;;;;;:::i;:::-;;;;;;;;6025:1212;;5764:1473:::0;;;;;;;:::o;3128:430:14:-;3224:4;3256:27;3244:8;:39;;;;;;;;:::i;:::-;;3240:312;;3306:18;;:44;;-1:-1:-1;;;3306:44:14;;;;;1176:25:28;;;-1:-1:-1;;;;;3306:18:14;;;;:35;;1149:18:28;;3306:44:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;;-1:-1:-1;3299:56:14;;3240:312;3388:26;3376:8;:38;;;;;;;;:::i;:::-;;3372:180;;3437:17;;:43;;-1:-1:-1;;;3437:43:14;;;;;1176:25:28;;;-1:-1:-1;;;;;3437:17:14;;;;:34;;1149:18:28;;3437:43:14;1030:177:28;3372:180:14;3516:25;;-1:-1:-1;;;3516:25:14;;16220:2:28;3516:25:14;;;16202:21:28;16259:2;16239:18;;;16232:30;16298:17;16278:18;;;16271:45;16333:18;;3516:25:14;16018:339:28;3577:432:17;1094:13:0;:11;:13::i;:::-;3649:12:17::1;::::0;;;:5:::1;:12;::::0;;;;;;;:19;;-1:-1:-1;;;;;;3649:19:17::1;-1:-1:-1::0;;;;;3649:19:17;;::::1;::::0;;;::::1;::::0;;;3761:30;;;;;;;3649:12;;;3761:28;;::::1;::::0;::::1;::::0;:30:::1;::::0;;::::1;::::0;3649:12;;3761:30;;;;;:28;:30:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3740:51;;::::0;-1:-1:-1;3894:14:17::1;3859:32;3740:51:::0;589:2:::1;3859:32;:::i;:::-;:49;;;;:::i;:::-;3852:57;::::0;:2:::1;:57;:::i;:::-;-1:-1:-1::0;;;;;3801:48:17;::::1;;::::0;;;:34:::1;:48;::::0;;;;:108;3969:32:::1;3988:13:::0;589:2:::1;3969:32;:::i;:::-;3962:40;::::0;:2:::1;:40;:::i;:::-;-1:-1:-1::0;;;;;3919:40:17;;::::1;;::::0;;;:26:::1;:40;::::0;;;;:83;;;;-1:-1:-1;;;3577:432:17:o;2081:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2169:22:0;::::1;2161:73;;;::::0;-1:-1:-1;;;2161:73:0;;18216:2:28;2161:73:0::1;::::0;::::1;18198:21:28::0;18255:2;18235:18;;;18228:30;18294:34;18274:18;;;18267:62;18365:8;18345:18;;;18338:36;18391:19;;2161:73:0::1;18014:402:28::0;2161:73:0::1;2244:28;2263:8;2244:18;:28::i;:::-;2081:198:::0;:::o;1359:130::-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;719:10:7;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;18623:2:28;1414:68:0;;;18605:21:28;;;18642:18;;;18635:30;18701:34;18681:18;;;18674:62;18753:18;;1414:68:0;18421:356:28;82:344:24;223:14;285:4;279;272:18;317:13;311:4;303:28;358:18;352:4;344:33;-1:-1:-1;;406:3:24;400:10;;82:344;-1:-1:-1;;82:344:24:o;5118:366:17:-;5214:4;5242:12;;;:5;:12;;;;;;-1:-1:-1;;;;;5242:12:17;;5264:55;;;;-1:-1:-1;;;5264:55:17;;18984:2:28;5264:55:17;;;18966:21:28;19023:2;19003:18;;;18996:30;19062:17;19042:18;;;19035:45;19097:18;;5264:55:17;18782:339:28;5264:55:17;5329:82;-1:-1:-1;;;;;5329:53:17;;5383:4;5397;5404:6;5329:53;:82::i;:::-;5466:10;;5428:49;;;;;-1:-1:-1;;;;;5458:18:17;;;5428:49;;;19322:74:28;;;19412:18;;;19405:34;;;5466:10:17;;;5458:18;;;19455::28;;;19448:50;5428:15:17;;;;;;19295:18:28;;5428:49:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5421:56;5118:366;-1:-1:-1;;;;;5118:366:17:o;4714:398::-;4877:4;4910:12;;;:5;:12;;;;;;-1:-1:-1;;;;;4910:12:17;;4932:68;;;;-1:-1:-1;;;4932:68:17;;19711:2:28;4932:68:17;;;19693:21:28;19750:2;19730:18;;;19723:30;19789:25;19769:18;;;19762:53;19832:18;;4932:68:17;19509:347:28;4932:68:17;5094:10;;5017:88;;;;;-1:-1:-1;;;;;5081:23:17;;;5017:88;;;20086:74:28;;;20176:18;;;20169:34;;;20219:18;;;20212:34;;;5094:10:17;;;5081:23;;;20262:18:28;;;20255:50;5017:22:17;;;;;;20058:19:28;;5017:88:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5010:95;;;4714:398;;;;;;;:::o;13379:576:10:-;13534:4;13554:14;13572:1;13554:19;13550:33;;-1:-1:-1;13582:1:10;13575:8;;13550:33;13638:12;;13710:59;-1:-1:-1;;;;;13710:22:10;;13733:4;13747;13754:14;13710:22;:59::i;:::-;13862:9;;:24;;;;;13878:7;13862:24;;;1176:25:28;13780:8:10;;-1:-1:-1;;;;;13862:9:10;;:15;;1149:18:28;;13862:24:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;13792:49:10;;;;;;:34;:49;;;;;;:66;;13844:14;;13792:66;:::i;:::-;13791:95;;;;:::i;:::-;13780:106;;13902:26;13924:3;13902:26;;;;1176:25:28;;1164:2;1149:18;;1030:177;13902:26:10;;;;;;;;13945:3;13379:576;-1:-1:-1;;;;;;13379:576:10:o;11598:1274::-;11868:7;11846:18;:29;11838:73;;;;-1:-1:-1;;;11838:73:10;;20691:2:28;11838:73:10;;;20673:21:28;20730:2;20710:18;;;20703:30;20769:33;20749:18;;;20742:61;20820:18;;11838:73:10;20489:355:28;11838:73:10;11929:37;;;;:17;:37;;;;;;;;:51;;;;;;;;;;;11921:94;;;;-1:-1:-1;;;11921:94:10;;21051:2:28;11921:94:10;;;21033:21:28;21090:2;21070:18;;;21063:30;21129:32;21109:18;;;21102:60;21179:18;;11921:94:10;20849:354:28;11921:94:10;12043:190;;-1:-1:-1;;;12043:190:10;;12025:15;;12043:4;;:16;;:190;;12073:6;;12093:9;;12116:7;;12137:18;;12169:12;;12195:5;;12214:9;;12043:190;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12252:21;;;;:12;:21;;;;;;12025:208;;-1:-1:-1;12252:26:10;12244:66;;;;-1:-1:-1;;;12244:66:10;;21410:2:28;12244:66:10;;;21392:21:28;21449:2;21429:18;;;21422:30;21488:29;21468:18;;;21461:57;21535:18;;12244:66:10;21208:351:28;12244:66:10;12377:21;;;;:12;:21;;;;;;12401:1;12377:25;;12442:43;-1:-1:-1;;;12442:43:10;;;;;1176:25:28;;;12442:4:10;;:23;;1149:18:28;;12442:43:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12413:72;;12495:27;12525:32;12538:7;12547:9;12525:12;:32::i;:::-;12572:57;;;8464:25:28;;;8520:2;8505:18;;8498:34;;;12495:62:10;;-1:-1:-1;12572:57:10;;8437:18:28;12572:57:10;;;;;;;12710:22;12686:21;:46;12671:11;:61;;12663:96;;;;-1:-1:-1;;;12663:96:10;;21766:2:28;12663:96:10;;;21748:21:28;21805:2;21785:18;;;21778:30;21844:24;21824:18;;;21817:52;21886:18;;12663:96:10;21564:346:28;12663:96:10;12784:81;12795:6;12803:9;12814:18;12834:12;12848:5;12855:9;12784:81;;;;;;;;;;;:::i;:::-;;;;;;;;11828:1044;;;11598:1274;;;;;;;:::o;2433:187:0:-;2506:16;2525:6;;-1:-1:-1;;;;;2541:17:0;;;-1:-1:-1;;;;;;2541:17:0;;;;;;2573:40;;2525:6;;;;;;;2573:40;;2506:16;2573:40;2496:124;2433:187;:::o;763:205:5:-;902:58;;-1:-1:-1;;;;;206:55:28;;902:58:5;;;188:74:28;278:18;;;271:34;;;875:86:5;;895:5;;925:23;;161:18:28;;902:58:5;;;;-1:-1:-1;;902:58:5;;;;;;;;;;;;;;;;;;;;;;;;;;;875:19;:86::i;:::-;763:205;;;:::o;974:241::-;1139:68;;-1:-1:-1;;;;;22783:15:28;;;1139:68:5;;;22765:34:28;22835:15;;22815:18;;;22808:43;22867:18;;;22860:34;;;1112:96:5;;1132:5;;1162:27;;22677:18:28;;1139:68:5;22502:398:28;1112:96:5;974:241;;;;:::o;3954:604:14:-;4039:16;4083:27;4071:8;:39;;;;;;;;:::i;:::-;;4067:485;;4140:18;;:56;;-1:-1:-1;;;4140:56:14;;:18;4184:10;;;4140:56;;;798:36:28;-1:-1:-1;;;;;4140:18:14;;;;:37;;771:18:28;;4140:56:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4210:18;;:59;;-1:-1:-1;;;4210:59:14;;;;;1176:25:28;;;4126:70:14;;-1:-1:-1;;;;;;4210:18:14;;:30;;4126:70;;1149:18:28;;4210:59:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4067:485;;;4302:26;4290:8;:38;;;;;;;;:::i;:::-;;4286:266;;4358:17;;:55;;-1:-1:-1;;;4358:55:14;;:17;4401:10;;;4358:55;;;798:36:28;-1:-1:-1;;;;;4358:17:14;;;;:36;;771:18:28;;4358:55:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4427:17;;:58;;-1:-1:-1;;;4427:58:14;;;;;1176:25:28;;;4344:69:14;;-1:-1:-1;;;;;;4427:17:14;;:29;;4344:69;;1149:18:28;;4427:58:14;1030:177:28;3747:706:5;4166:23;4192:69;4220:4;4192:69;;;;;;;;;;;;;;;;;4200:5;-1:-1:-1;;;;;4192:27:5;;;:69;;;;;:::i;:::-;4275:17;;4166:95;;-1:-1:-1;4275:21:5;4271:176;;4370:10;4359:30;;;;;;;;;;;;:::i;:::-;4351:85;;;;-1:-1:-1;;;4351:85:5;;23487:2:28;4351:85:5;;;23469:21:28;23526:2;23506:18;;;23499:30;23565:34;23545:18;;;23538:62;23636:12;23616:18;;;23609:40;23666:19;;4351:85:5;23285:406:28;3873:223:6;4006:12;4037:52;4059:6;4067:4;4073:1;4076:12;4006;5241;5255:23;5282:6;-1:-1:-1;;;;;5282:11:6;5301:5;5308:4;5282:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5240:73;;;;5330:69;5357:6;5365:7;5374:10;5386:12;7646;7674:7;7670:418;;;7701:10;:17;7722:1;7701:22;7697:286;;-1:-1:-1;;;;;1465:19:6;;;7908:60;;;;-1:-1:-1;;;7908:60:6;;24852:2:28;7908:60:6;;;24834:21:28;24891:2;24871:18;;;24864:30;24930:31;24910:18;;;24903:59;24979:18;;7908:60:6;24650:353:28;7908:60:6;-1:-1:-1;8003:10:6;7996:17;;7670:418;8044:33;8052:10;8064:12;8775:17;;:21;8771:379;;9003:10;8997:17;9059:15;9046:10;9042:2;9038:19;9031:44;8771:379;9126:12;9119:20;;-1:-1:-1;;;9119:20:6;;;;;;;;:::i;845:180:28:-;904:6;957:2;945:9;936:7;932:23;928:32;925:52;;;973:1;970;963:12;925:52;-1:-1:-1;996:23:28;;845:180;-1:-1:-1;845:180:28:o;1212:248::-;1280:6;1288;1341:2;1329:9;1320:7;1316:23;1312:32;1309:52;;;1357:1;1354;1347:12;1309:52;-1:-1:-1;;1380:23:28;;;1450:2;1435:18;;;1422:32;;-1:-1:-1;1212:248:28:o;1839:158::-;1922:20;;1971:1;1961:12;;1951:40;;1987:1;1984;1977:12;1951:40;1839:158;;;:::o;2002:635::-;2137:6;2145;2153;2161;2169;2177;2185;2238:3;2226:9;2217:7;2213:23;2209:33;2206:53;;;2255:1;2252;2245:12;2206:53;2291:9;2278:23;2268:33;;2348:2;2337:9;2333:18;2320:32;2310:42;;2399:2;2388:9;2384:18;2371:32;2361:42;;2450:2;2439:9;2435:18;2422:32;2412:42;;2501:3;2490:9;2486:19;2473:33;2463:43;;2553:3;2542:9;2538:19;2525:33;2515:43;;2577:54;2626:3;2615:9;2611:19;2577:54;:::i;:::-;2567:64;;2002:635;;;;;;;;;;:::o;2642:154::-;-1:-1:-1;;;;;2721:5:28;2717:54;2710:5;2707:65;2697:93;;2786:1;2783;2776:12;2801:521;2896:6;2904;2912;2920;2928;2981:3;2969:9;2960:7;2956:23;2952:33;2949:53;;;2998:1;2995;2988:12;2949:53;3034:9;3021:23;3011:33;;3091:2;3080:9;3076:18;3063:32;3053:42;;3142:2;3131:9;3127:18;3114:32;3104:42;;3196:2;3185:9;3181:18;3168:32;3209:31;3234:5;3209:31;:::i;:::-;2801:521;;;;-1:-1:-1;2801:521:28;;3311:3;3296:19;3283:33;;2801:521;-1:-1:-1;;2801:521:28:o;3327:247::-;3386:6;3439:2;3427:9;3418:7;3414:23;3410:32;3407:52;;;3455:1;3452;3445:12;3407:52;3494:9;3481:23;3513:31;3538:5;3513:31;:::i;3579:704::-;3723:6;3731;3739;3747;3755;3763;3771;3779;3832:3;3820:9;3811:7;3807:23;3803:33;3800:53;;;3849:1;3846;3839:12;3800:53;3885:9;3872:23;3862:33;;3942:2;3931:9;3927:18;3914:32;3904:42;;3993:2;3982:9;3978:18;3965:32;3955:42;;4044:2;4033:9;4029:18;4016:32;4006:42;;4095:3;4084:9;4080:19;4067:33;4057:43;;4147:3;4136:9;4132:19;4119:33;4109:43;;4171:54;4220:3;4209:9;4205:19;4171:54;:::i;:::-;4161:64;;4272:3;4261:9;4257:19;4244:33;4234:43;;3579:704;;;;;;;;;;;:::o;4541:291::-;4631:6;4639;4692:2;4680:9;4671:7;4667:23;4663:32;4660:52;;;4708:1;4705;4698:12;4660:52;4744:9;4731:23;4721:33;;4773:53;4822:2;4811:9;4807:18;4773:53;:::i;:::-;4763:63;;4541:291;;;;;:::o;4837:426::-;4936:6;4944;4952;5005:2;4993:9;4984:7;4980:23;4976:32;4973:52;;;5021:1;5018;5011:12;4973:52;5057:9;5044:23;5034:33;;5086:53;5135:2;5124:9;5120:18;5086:53;:::i;:::-;5076:63;;5189:2;5178:9;5174:18;5161:32;5202:31;5227:5;5202:31;:::i;:::-;5252:5;5242:15;;;4837:426;;;;;:::o;7021:635::-;7156:6;7164;7172;7180;7188;7196;7204;7257:3;7245:9;7236:7;7232:23;7228:33;7225:53;;;7274:1;7271;7264:12;7225:53;7310:9;7297:23;7287:33;;7367:2;7356:9;7352:18;7339:32;7329:42;;7418:2;7407:9;7403:18;7390:32;7380:42;;7469:2;7458:9;7454:18;7441:32;7431:42;;7520:3;7509:9;7505:19;7492:33;7482:43;;7544:54;7593:3;7582:9;7578:19;7544:54;:::i;:::-;7534:64;;7645:3;7634:9;7630:19;7617:33;7607:43;;7021:635;;;;;;;;;;:::o;7957:328::-;8038:6;8046;8099:2;8087:9;8078:7;8074:23;8070:32;8067:52;;;8115:1;8112;8105:12;8067:52;8154:9;8141:23;8173:31;8198:5;8173:31;:::i;:::-;8223:5;8275:2;8260:18;;;;8247:32;;-1:-1:-1;;;7957:328:28:o;8543:184::-;8613:6;8666:2;8654:9;8645:7;8641:23;8637:32;8634:52;;;8682:1;8679;8672:12;8634:52;-1:-1:-1;8705:16:28;;8543:184;-1:-1:-1;8543:184:28:o;8732:::-;-1:-1:-1;;;8781:1:28;8774:88;8881:4;8878:1;8871:15;8905:4;8902:1;8895:15;8921:750;9222:6;9217:3;9210:19;9259:6;9254:2;9249:3;9245:12;9238:28;9296:6;9291:2;9286:3;9282:12;9275:28;9333:6;9328:2;9323:3;9319:12;9312:28;9371:6;9365:3;9360;9356:13;9349:29;9192:3;9408:1;9400:6;9397:13;9387:201;;-1:-1:-1;;;9441:1:28;9434:88;9545:4;9542:1;9535:15;9573:4;9570:1;9563:15;9387:201;-1:-1:-1;9623:3:28;9619:16;;;;9613:3;9604:13;;9597:39;9661:3;9652:13;;8921:750;-1:-1:-1;;;;;8921:750:28:o;11409:184::-;-1:-1:-1;;;11458:1:28;11451:88;11558:4;11555:1;11548:15;11582:4;11579:1;11572:15;11598:125;11663:9;;;11684:10;;;11681:36;;;11697:18;;:::i;11728:128::-;11795:9;;;11816:11;;;11813:37;;;11830:18;;:::i;11861:274::-;11901:1;11927;11917:189;;-1:-1:-1;;;11959:1:28;11952:88;12063:4;12060:1;12053:15;12091:4;12088:1;12081:15;11917:189;-1:-1:-1;12120:9:28;;11861:274::o;12855:302::-;12944:1;12937:5;12934:12;12924:200;;-1:-1:-1;;;12977:1:28;12970:88;13081:4;13078:1;13071:15;13109:4;13106:1;13099:15;12924:200;13133:18;;12855:302::o;13162:654::-;13442:4;13484:3;13473:9;13469:19;13461:27;;13515:6;13504:9;13497:25;13558:6;13553:2;13542:9;13538:18;13531:34;13601:6;13596:2;13585:9;13581:18;13574:34;13644:6;13639:2;13628:9;13624:18;13617:34;13688:6;13682:3;13671:9;13667:19;13660:35;13732:6;13726:3;13715:9;13711:19;13704:35;13748:62;13805:3;13794:9;13790:19;13782:6;13748:62;:::i;:::-;13162:654;;;;;;;;;;:::o;14364:295::-;14558:25;;;14546:2;14531:18;;14592:61;14649:2;14634:18;;14626:6;14592:61;:::i;14664:277::-;14731:6;14784:2;14772:9;14763:7;14759:23;14755:32;14752:52;;;14800:1;14797;14790:12;14752:52;14832:9;14826:16;14885:5;14878:13;14871:21;14864:5;14861:32;14851:60;;14907:1;14904;14897:12;15503:510;15782:25;;;15838:2;15823:18;;15816:34;;;15881:2;15866:18;;15859:34;;;15769:3;15754:19;;15902:61;15959:2;15944:18;;15936:6;15902:61;:::i;:::-;16000:6;15994:3;15983:9;15979:19;15972:35;15503:510;;;;;;;;:::o;16362:273::-;16430:6;16483:2;16471:9;16462:7;16458:23;16454:32;16451:52;;;16499:1;16496;16489:12;16451:52;16531:9;16525:16;16581:4;16574:5;16570:16;16563:5;16560:27;16550:55;;16601:1;16598;16591:12;16640:422;16729:1;16772:5;16729:1;16786:270;16807:7;16797:8;16794:21;16786:270;;;16866:4;16862:1;16858:6;16854:17;16848:4;16845:27;16842:53;;;16875:18;;:::i;:::-;16925:7;16915:8;16911:22;16908:55;;;16945:16;;;;16908:55;17024:22;;;;16984:15;;;;16786:270;;;16790:3;16640:422;;;;;:::o;17067:806::-;17116:5;17146:8;17136:80;;-1:-1:-1;17187:1:28;17201:5;;17136:80;17235:4;17225:76;;-1:-1:-1;17272:1:28;17286:5;;17225:76;17317:4;17335:1;17330:59;;;;17403:1;17398:130;;;;17310:218;;17330:59;17360:1;17351:10;;17374:5;;;17398:130;17435:3;17425:8;17422:17;17419:43;;;17442:18;;:::i;:::-;-1:-1:-1;;17498:1:28;17484:16;;17513:5;;17310:218;;17612:2;17602:8;17599:16;17593:3;17587:4;17584:13;17580:36;17574:2;17564:8;17561:16;17556:2;17550:4;17547:12;17543:35;17540:77;17537:159;;;-1:-1:-1;17649:19:28;;;17681:5;;17537:159;17728:34;17753:8;17747:4;17728:34;:::i;:::-;17798:6;17794:1;17790:6;17786:19;17777:7;17774:32;17771:58;;;17809:18;;:::i;:::-;17847:20;;17067:806;-1:-1:-1;;;17067:806:28:o;17878:131::-;17938:5;17967:36;17994:8;17988:4;17967:36;:::i;20316:168::-;20389:9;;;20420;;20437:15;;;20431:22;;20417:37;20407:71;;20458:18;;:::i;21915:582::-;22167:4;22209:3;22198:9;22194:19;22186:27;;22240:6;22229:9;22222:25;22283:6;22278:2;22267:9;22263:18;22256:34;22326:6;22321:2;22310:9;22306:18;22299:34;22369:6;22364:2;22353:9;22349:18;22342:34;22413:6;22407:3;22396:9;22392:19;22385:35;22429:62;22486:3;22475:9;22471:19;22463:6;22429:62;:::i;24103:250::-;24188:1;24198:113;24212:6;24209:1;24206:13;24198:113;;;24288:11;;;24282:18;24269:11;;;24262:39;24234:2;24227:10;24198:113;;;-1:-1:-1;;24345:1:28;24327:16;;24320:27;24103:250::o;24358:287::-;24487:3;24525:6;24519:13;24541:66;24600:6;24595:3;24588:4;24580:6;24576:17;24541:66;:::i;:::-;24623:16;;;;;24358:287;-1:-1:-1;;24358:287:28:o;25008:396::-;25157:2;25146:9;25139:21;25120:4;25189:6;25183:13;25232:6;25227:2;25216:9;25212:18;25205:34;25248:79;25320:6;25315:2;25304:9;25300:18;25295:2;25287:6;25283:15;25248:79;:::i;:::-;25388:2;25367:15;-1:-1:-1;;25363:29:28;25348:45;;;;25395:2;25344:54;;25008:396;-1:-1:-1;;25008:396:28:o
Swarm Source
ipfs://927398be6ba13ed822ffd71f0e06604d56057496cd4aa5bfebae5e2875e63f64
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
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.