Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Transfer Ownersh... | 18335294 | 420 days ago | IN | 0 ETH | 0.00065629 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x057152DB...eE21fE1b4 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
BurnMintTokenPool
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 26000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.19; import {IBurnMintERC20} from "../../shared/token/ERC20/IBurnMintERC20.sol"; import {TokenPool} from "./TokenPool.sol"; /// @notice This pool mints and burns a 3rd-party token. /// @dev Pool whitelisting mode is set in the constructor and cannot be modified later. /// It either accepts any address as originalSender, or only accepts whitelisted originalSender. /// The only way to change whitelisting mode is to deploy a new pool. /// If that is expected, please make sure the token's burner/minter roles are adjustable. contract BurnMintTokenPool is TokenPool { constructor( IBurnMintERC20 token, address[] memory allowlist, address armProxy ) TokenPool(token, allowlist, armProxy) {} /// @notice Burn the token in the pool /// @dev Burn is not rate limited at per-pool level. Burn does not contribute to honey pot risk. /// Benefits of rate limiting here does not justify the extra gas cost. /// @param amount Amount to burn function lockOrBurn( address originalSender, bytes calldata, uint256 amount, uint64, bytes calldata ) external override onlyOnRamp checkAllowList(originalSender) whenHealthy returns (bytes memory) { _consumeOnRampRateLimit(amount); IBurnMintERC20(address(i_token)).burn(amount); emit Burned(msg.sender, amount); return ""; } /// @notice Mint tokens from the pool to the recipient /// @param receiver Recipient address /// @param amount Amount to mint function releaseOrMint( bytes memory, address receiver, uint256 amount, uint64, bytes memory ) external virtual override whenHealthy onlyOffRamp { _consumeOffRampRateLimit(amount); IBurnMintERC20(address(i_token)).mint(receiver, amount); emit Minted(msg.sender, receiver, amount); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {IERC20} from "../../../vendor/openzeppelin-solidity/v4.8.0/token/ERC20/IERC20.sol"; interface IBurnMintERC20 is IERC20 { /// @notice Mints new tokens for a given address. /// @param account The address to mint the new tokens to. /// @param amount The number of tokens to be minted. /// @dev this function increases the total supply. function mint(address account, uint256 amount) external; /// @notice Burns tokens from the sender. /// @param amount The number of tokens to be burned. /// @dev this function decreases the total supply. function burn(uint256 amount) external; /// @notice Burns tokens from a given address.. /// @param account The address to burn tokens from. /// @param amount The number of tokens to be burned. /// @dev this function decreases the total supply. function burnFrom(address account, uint256 amount) external; }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.19; import {IPool} from "../interfaces/pools/IPool.sol"; import {IARM} from "../interfaces/IARM.sol"; import {OwnerIsCreator} from "../../shared/access/OwnerIsCreator.sol"; import {RateLimiter} from "../libraries/RateLimiter.sol"; import {Pausable} from "../../vendor/Pausable.sol"; import {IERC20} from "../../vendor/openzeppelin-solidity/v4.8.0/token/ERC20/IERC20.sol"; import {IERC165} from "../../vendor/openzeppelin-solidity/v4.8.0/utils/introspection/IERC165.sol"; import {EnumerableSet} from "../../vendor/openzeppelin-solidity/v4.8.0/utils/structs/EnumerableSet.sol"; /// @notice Base abstract class with common functions for all token pools. abstract contract TokenPool is IPool, OwnerIsCreator, IERC165 { using EnumerableSet for EnumerableSet.AddressSet; using RateLimiter for RateLimiter.TokenBucket; error PermissionsError(); error ZeroAddressNotAllowed(); error SenderNotAllowed(address sender); error AllowListNotEnabled(); error NonExistentRamp(address ramp); error BadARMSignal(); error RampAlreadyExists(address ramp); event Locked(address indexed sender, uint256 amount); event Burned(address indexed sender, uint256 amount); event Released(address indexed sender, address indexed recipient, uint256 amount); event Minted(address indexed sender, address indexed recipient, uint256 amount); event OnRampAdded(address onRamp, RateLimiter.Config rateLimiterConfig); event OnRampConfigured(address onRamp, RateLimiter.Config rateLimiterConfig); event OnRampRemoved(address onRamp); event OffRampAdded(address offRamp, RateLimiter.Config rateLimiterConfig); event OffRampConfigured(address offRamp, RateLimiter.Config rateLimiterConfig); event OffRampRemoved(address offRamp); event AllowListAdd(address sender); event AllowListRemove(address sender); struct RampUpdate { address ramp; bool allowed; RateLimiter.Config rateLimiterConfig; } // The immutable token that belongs to this pool. IERC20 internal immutable i_token; address internal immutable i_armProxy; // The immutable flag that indicates if the pool is access-controlled. bool internal immutable i_allowlistEnabled; // A set of addresses allowed to trigger lockOrBurn as original senders. EnumerableSet.AddressSet internal s_allowList; // A set of allowed onRamps. We want the whitelist to be enumerable to // be able to quickly determine (without parsing logs) who can access the pool. EnumerableSet.AddressSet internal s_onRamps; mapping(address => RateLimiter.TokenBucket) internal s_onRampRateLimits; // A set of allowed offRamps. EnumerableSet.AddressSet internal s_offRamps; mapping(address => RateLimiter.TokenBucket) internal s_offRampRateLimits; constructor(IERC20 token, address[] memory allowlist, address armProxy) { if (address(token) == address(0)) revert ZeroAddressNotAllowed(); i_token = token; i_armProxy = armProxy; // Pool can be set as permissioned or permissionless at deployment time only. i_allowlistEnabled = allowlist.length > 0; if (i_allowlistEnabled) { _applyAllowListUpdates(new address[](0), allowlist); } } /// @notice Get ARM proxy address /// @return armProxy Address of arm proxy function getArmProxy() public view returns (address armProxy) { return i_armProxy; } /// @inheritdoc IPool function getToken() public view override returns (IERC20 token) { return i_token; } /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public pure virtual override returns (bool) { return interfaceId == type(IPool).interfaceId || interfaceId == type(IERC165).interfaceId; } // ================================================================ // | Ramp permissions | // ================================================================ /// @notice Checks whether something is a permissioned onRamp on this contract. /// @return true if the given address is a permissioned onRamp. function isOnRamp(address onRamp) public view returns (bool) { return s_onRamps.contains(onRamp); } /// @notice Checks whether something is a permissioned offRamp on this contract. /// @return true if the given address is a permissioned offRamp. function isOffRamp(address offRamp) public view returns (bool) { return s_offRamps.contains(offRamp); } /// @notice Get onRamp whitelist /// @return list of onramps. function getOnRamps() public view returns (address[] memory) { return s_onRamps.values(); } /// @notice Get offRamp whitelist /// @return list of offramps function getOffRamps() public view returns (address[] memory) { return s_offRamps.values(); } /// @notice Sets permissions for all on and offRamps. /// @dev Only callable by the owner /// @param onRamps A list of onRamps and their new permission status/rate limits /// @param offRamps A list of offRamps and their new permission status/rate limits function applyRampUpdates(RampUpdate[] calldata onRamps, RampUpdate[] calldata offRamps) external virtual onlyOwner { _applyRampUpdates(onRamps, offRamps); } function _applyRampUpdates(RampUpdate[] calldata onRamps, RampUpdate[] calldata offRamps) internal onlyOwner { for (uint256 i = 0; i < onRamps.length; ++i) { RampUpdate memory update = onRamps[i]; if (update.allowed) { if (s_onRamps.add(update.ramp)) { s_onRampRateLimits[update.ramp] = RateLimiter.TokenBucket({ rate: update.rateLimiterConfig.rate, capacity: update.rateLimiterConfig.capacity, tokens: update.rateLimiterConfig.capacity, lastUpdated: uint32(block.timestamp), isEnabled: update.rateLimiterConfig.isEnabled }); emit OnRampAdded(update.ramp, update.rateLimiterConfig); } else { revert RampAlreadyExists(update.ramp); } } else { if (s_onRamps.remove(update.ramp)) { delete s_onRampRateLimits[update.ramp]; emit OnRampRemoved(update.ramp); } else { // Cannot remove a non-existent onRamp. revert NonExistentRamp(update.ramp); } } } for (uint256 i = 0; i < offRamps.length; ++i) { RampUpdate memory update = offRamps[i]; if (update.allowed) { if (s_offRamps.add(update.ramp)) { s_offRampRateLimits[update.ramp] = RateLimiter.TokenBucket({ rate: update.rateLimiterConfig.rate, capacity: update.rateLimiterConfig.capacity, tokens: update.rateLimiterConfig.capacity, lastUpdated: uint32(block.timestamp), isEnabled: update.rateLimiterConfig.isEnabled }); emit OffRampAdded(update.ramp, update.rateLimiterConfig); } else { revert RampAlreadyExists(update.ramp); } } else { if (s_offRamps.remove(update.ramp)) { delete s_offRampRateLimits[update.ramp]; emit OffRampRemoved(update.ramp); } else { // Cannot remove a non-existent offRamp. revert NonExistentRamp(update.ramp); } } } } // ================================================================ // | Rate limiting | // ================================================================ /// @notice Consumes outbound rate limiting capacity in this pool function _consumeOnRampRateLimit(uint256 amount) internal { s_onRampRateLimits[msg.sender]._consume(amount, address(i_token)); } /// @notice Consumes inbound rate limiting capacity in this pool function _consumeOffRampRateLimit(uint256 amount) internal { s_offRampRateLimits[msg.sender]._consume(amount, address(i_token)); } /// @notice Gets the token bucket with its values for the block it was requested at. /// @return The token bucket. function currentOnRampRateLimiterState(address onRamp) external view returns (RateLimiter.TokenBucket memory) { return s_onRampRateLimits[onRamp]._currentTokenBucketState(); } /// @notice Gets the token bucket with its values for the block it was requested at. /// @return The token bucket. function currentOffRampRateLimiterState(address offRamp) external view returns (RateLimiter.TokenBucket memory) { return s_offRampRateLimits[offRamp]._currentTokenBucketState(); } /// @notice Sets the onramp rate limited config. /// @param config The new rate limiter config. function setOnRampRateLimiterConfig(address onRamp, RateLimiter.Config memory config) external onlyOwner { if (!isOnRamp(onRamp)) revert NonExistentRamp(onRamp); s_onRampRateLimits[onRamp]._setTokenBucketConfig(config); emit OnRampConfigured(onRamp, config); } /// @notice Sets the offramp rate limited config. /// @param config The new rate limiter config. function setOffRampRateLimiterConfig(address offRamp, RateLimiter.Config memory config) external onlyOwner { if (!isOffRamp(offRamp)) revert NonExistentRamp(offRamp); s_offRampRateLimits[offRamp]._setTokenBucketConfig(config); emit OffRampConfigured(offRamp, config); } // ================================================================ // | Access | // ================================================================ /// @notice Checks whether the msg.sender is a permissioned onRamp on this contract /// @dev Reverts with a PermissionsError if check fails modifier onlyOnRamp() { if (!isOnRamp(msg.sender)) revert PermissionsError(); _; } /// @notice Checks whether the msg.sender is a permissioned offRamp on this contract /// @dev Reverts with a PermissionsError if check fails modifier onlyOffRamp() { if (!isOffRamp(msg.sender)) revert PermissionsError(); _; } // ================================================================ // | Allowlist | // ================================================================ modifier checkAllowList(address sender) { if (i_allowlistEnabled && !s_allowList.contains(sender)) revert SenderNotAllowed(sender); _; } /// @notice Gets whether the allowList functionality is enabled. /// @return true is enabled, false if not. function getAllowListEnabled() external view returns (bool) { return i_allowlistEnabled; } /// @notice Gets the allowed addresses. /// @return The allowed addresses. function getAllowList() external view returns (address[] memory) { return s_allowList.values(); } /// @notice Apply updates to the allow list. /// @param removes The addresses to be removed. /// @param adds The addresses to be added. /// @dev allowListing will be removed before public launch function applyAllowListUpdates(address[] calldata removes, address[] calldata adds) external onlyOwner { _applyAllowListUpdates(removes, adds); } /// @notice Internal version of applyAllowListUpdates to allow for reuse in the constructor. function _applyAllowListUpdates(address[] memory removes, address[] memory adds) internal { if (!i_allowlistEnabled) revert AllowListNotEnabled(); for (uint256 i = 0; i < removes.length; ++i) { address toRemove = removes[i]; if (s_allowList.remove(toRemove)) { emit AllowListRemove(toRemove); } } for (uint256 i = 0; i < adds.length; ++i) { address toAdd = adds[i]; if (toAdd == address(0)) { continue; } if (s_allowList.add(toAdd)) { emit AllowListAdd(toAdd); } } } /// @notice Ensure that the ARM has not emitted a bad signal, and that the latest heartbeat is not stale. modifier whenHealthy() { if (IARM(i_armProxy).isCursed()) revert BadARMSignal(); _; } }
// 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: BUSL-1.1 pragma solidity ^0.8.0; import {IERC20} from "../../../vendor/openzeppelin-solidity/v4.8.0/token/ERC20/IERC20.sol"; // Shared public interface for multiple pool types. // Each pool type handles a different child token model (lock/unlock, mint/burn.) interface IPool { /// @notice Lock tokens into the pool or burn the tokens. /// @param originalSender Original sender of the tokens. /// @param receiver Receiver of the tokens on destination chain. /// @param amount Amount to lock or burn. /// @param destChainSelector Destination chain Id. /// @param extraArgs Additional data passed in by sender for lockOrBurn processing /// in custom pools on source chain. /// @return retData Optional field that contains bytes. Unused for now but already /// implemented to allow future upgrades while preserving the interface. function lockOrBurn( address originalSender, bytes calldata receiver, uint256 amount, uint64 destChainSelector, bytes calldata extraArgs ) external returns (bytes memory); /// @notice Releases or mints tokens to the receiver address. /// @param originalSender Original sender of the tokens. /// @param receiver Receiver of the tokens. /// @param amount Amount to release or mint. /// @param sourceChainSelector Source chain Id. /// @param extraData Additional data supplied offchain for releaseOrMint processing in /// custom pools on dest chain. This could be an attestation that was retrieved through a /// third party API. /// @dev offchainData can come from any untrusted source. function releaseOrMint( bytes memory originalSender, address receiver, uint256 amount, uint64 sourceChainSelector, bytes memory extraData ) external; /// @notice Gets the IERC20 token that this pool can lock or burn. /// @return token The IERC20 token representation. function getToken() external view returns (IERC20 token); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; /// @notice This interface contains the only ARM-related functions that might be used on-chain by other CCIP contracts. interface IARM { /// @notice A Merkle root tagged with the address of the commit store contract it is destined for. struct TaggedRoot { address commitStore; bytes32 root; } /// @notice Callers MUST NOT cache the return value as a blessed tagged root could become unblessed. function isBlessed(TaggedRoot calldata taggedRoot) external view returns (bool); /// @notice When the ARM is "cursed", CCIP pauses until the curse is lifted. function isCursed() external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import {ConfirmedOwner} from "../../ConfirmedOwner.sol"; /// @title The OwnerIsCreator contract /// @notice A contract with helpers for basic contract ownership. contract OwnerIsCreator is ConfirmedOwner { constructor() ConfirmedOwner(msg.sender) {} }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; /// @notice Implements Token Bucket rate limiting. /// @dev uint128 is safe for rate limiter state. /// For USD value rate limiting, it can adequately store USD value in 18 decimals. /// For ERC20 token amount rate limiting, all tokens that will be listed will have at most /// a supply of uint128.max tokens, and it will therefore not overflow the bucket. /// In exceptional scenarios where tokens consumed may be larger than uint128, /// e.g. compromised issuer, an enabled RateLimiter will check and revert. library RateLimiter { error BucketOverfilled(); error OnlyCallableByAdminOrOwner(); error TokenMaxCapacityExceeded(uint256 capacity, uint256 requested, address tokenAddress); error TokenRateLimitReached(uint256 minWaitInSeconds, uint256 available, address tokenAddress); error AggregateValueMaxCapacityExceeded(uint256 capacity, uint256 requested); error AggregateValueRateLimitReached(uint256 minWaitInSeconds, uint256 available); event TokensConsumed(uint256 tokens); event ConfigChanged(Config config); struct TokenBucket { uint128 tokens; // ------┐ Current number of tokens that are in the bucket. uint32 lastUpdated; // | Timestamp in seconds of the last token refill, good for 100+ years. bool isEnabled; // ------┘ Indication whether the rate limiting is enabled or not uint128 capacity; // ----┐ Maximum number of tokens that can be in the bucket. uint128 rate; // --------┘ Number of tokens per second that the bucket is refilled. } struct Config { bool isEnabled; // Indication whether the rate limiting should be enabled uint128 capacity; // ----┐ Specifies the capacity of the rate limiter uint128 rate; // -------┘ Specifies the rate of the rate limiter } /// @notice _consume removes the given tokens from the pool, lowering the /// rate tokens allowed to be consumed for subsequent calls. /// @param requestTokens The total tokens to be consumed from the bucket. /// @param tokenAddress The token to consume capacity for, use 0x0 to indicate aggregate value capacity. /// @dev Reverts when requestTokens exceeds bucket capacity or available tokens in the bucket /// @dev emits removal of requestTokens if requestTokens is > 0 function _consume(TokenBucket storage s_bucket, uint256 requestTokens, address tokenAddress) internal { // If there is no value to remove or rate limiting is turned off, skip this step to reduce gas usage if (!s_bucket.isEnabled || requestTokens == 0) { return; } uint256 tokens = s_bucket.tokens; uint256 capacity = s_bucket.capacity; uint256 timeDiff = block.timestamp - s_bucket.lastUpdated; if (timeDiff != 0) { if (tokens > capacity) revert BucketOverfilled(); // Refill tokens when arriving at a new block time tokens = _calculateRefill(capacity, tokens, timeDiff, s_bucket.rate); s_bucket.lastUpdated = uint32(block.timestamp); } if (capacity < requestTokens) { // Token address 0 indicates consuming aggregate value rate limit capacity. if (tokenAddress == address(0)) revert AggregateValueMaxCapacityExceeded(capacity, requestTokens); revert TokenMaxCapacityExceeded(capacity, requestTokens, tokenAddress); } if (tokens < requestTokens) { uint256 rate = s_bucket.rate; // Wait required until the bucket is refilled enough to accept this value, round up to next higher second // Consume is not guaranteed to succeed after wait time passes if there is competing traffic. // This acts as a lower bound of wait time. uint256 minWaitInSeconds = ((requestTokens - tokens) + (rate - 1)) / rate; if (tokenAddress == address(0)) revert AggregateValueRateLimitReached(minWaitInSeconds, tokens); revert TokenRateLimitReached(minWaitInSeconds, tokens, tokenAddress); } tokens -= requestTokens; // Downcast is safe here, as tokens is not larger than capacity s_bucket.tokens = uint128(tokens); emit TokensConsumed(requestTokens); } /// @notice Gets the token bucket with its values for the block it was requested at. /// @return The token bucket. function _currentTokenBucketState(TokenBucket memory bucket) internal view returns (TokenBucket memory) { // We update the bucket to reflect the status at the exact time of the // call. This means we might need to refill a part of the bucket based // on the time that has passed since the last update. bucket.tokens = uint128( _calculateRefill(bucket.capacity, bucket.tokens, block.timestamp - bucket.lastUpdated, bucket.rate) ); bucket.lastUpdated = uint32(block.timestamp); return bucket; } /// @notice Sets the rate limited config. /// @param s_bucket The token bucket /// @param config The new config function _setTokenBucketConfig(TokenBucket storage s_bucket, Config memory config) internal { // First update the bucket to make sure the proper rate is used for all the time // up until the config change. uint256 timeDiff = block.timestamp - s_bucket.lastUpdated; if (timeDiff != 0) { s_bucket.tokens = uint128(_calculateRefill(s_bucket.capacity, s_bucket.tokens, timeDiff, s_bucket.rate)); s_bucket.lastUpdated = uint32(block.timestamp); } s_bucket.tokens = uint128(_min(config.capacity, s_bucket.tokens)); s_bucket.isEnabled = config.isEnabled; s_bucket.capacity = config.capacity; s_bucket.rate = config.rate; emit ConfigChanged(config); } /// @notice Calculate refilled tokens /// @param capacity bucket capacity /// @param tokens current bucket tokens /// @param timeDiff block time difference since last refill /// @param rate bucket refill rate /// @return the value of tokens after refill function _calculateRefill( uint256 capacity, uint256 tokens, uint256 timeDiff, uint256 rate ) private pure returns (uint256) { return _min(capacity, tokens + timeDiff * rate); } /// @notice Return the smallest of two integers /// @param a first int /// @param b second int /// @return smallest function _min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./ConfirmedOwnerWithProposal.sol"; /** * @title The ConfirmedOwner contract * @notice A contract with helpers for basic contract ownership. */ contract ConfirmedOwner is ConfirmedOwnerWithProposal { constructor(address newOwner) ConfirmedOwnerWithProposal(newOwner, address(0)) {} }
// SPDX-License-Identifier: MIT 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 pragma solidity ^0.8.0; import "./interfaces/OwnableInterface.sol"; /** * @title The ConfirmedOwner contract * @notice A contract with helpers for basic contract ownership. */ contract ConfirmedOwnerWithProposal is OwnableInterface { address private s_owner; address private s_pendingOwner; event OwnershipTransferRequested(address indexed from, address indexed to); event OwnershipTransferred(address indexed from, address indexed to); constructor(address newOwner, address pendingOwner) { require(newOwner != address(0), "Cannot set owner to zero"); s_owner = newOwner; if (pendingOwner != address(0)) { _transferOwnership(pendingOwner); } } /** * @notice Allows an owner to begin transferring ownership to a new address, * pending. */ function transferOwnership(address to) public override onlyOwner { _transferOwnership(to); } /** * @notice Allows an ownership transfer to be completed by the recipient. */ function acceptOwnership() external override { require(msg.sender == s_pendingOwner, "Must be proposed owner"); address oldOwner = s_owner; s_owner = msg.sender; s_pendingOwner = address(0); emit OwnershipTransferred(oldOwner, msg.sender); } /** * @notice Get the current owner */ function owner() public view override returns (address) { return s_owner; } /** * @notice validate, transfer ownership, and emit relevant events */ function _transferOwnership(address to) private { require(to != msg.sender, "Cannot transfer to self"); s_pendingOwner = to; emit OwnershipTransferRequested(s_owner, to); } /** * @notice validate access */ function _validateOwnership() internal view { require(msg.sender == s_owner, "Only callable by owner"); } /** * @notice Reverts if called by anyone other than the contract owner. */ modifier onlyOwner() { _validateOwnership(); _; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface OwnableInterface { function owner() external returns (address); function transferOwnership(address recipient) external; function acceptOwnership() external; }
{ "remappings": [ "@eth-optimism/=node_modules/@eth-optimism/", "@openzeppelin/=node_modules/@openzeppelin/", "ds-test/=foundry-lib/forge-std/lib/ds-test/src/", "erc4626-tests/=foundry-lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-std/=foundry-lib/forge-std/src/", "hardhat/=node_modules/hardhat/", "openzeppelin-contracts/=foundry-lib/openzeppelin-contracts/contracts/" ], "optimizer": { "enabled": true, "runs": 26000 }, "metadata": { "bytecodeHash": "none", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IBurnMintERC20","name":"token","type":"address"},{"internalType":"address[]","name":"allowlist","type":"address[]"},{"internalType":"address","name":"armProxy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"capacity","type":"uint256"},{"internalType":"uint256","name":"requested","type":"uint256"}],"name":"AggregateValueMaxCapacityExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"minWaitInSeconds","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"name":"AggregateValueRateLimitReached","type":"error"},{"inputs":[],"name":"AllowListNotEnabled","type":"error"},{"inputs":[],"name":"BadARMSignal","type":"error"},{"inputs":[],"name":"BucketOverfilled","type":"error"},{"inputs":[{"internalType":"address","name":"ramp","type":"address"}],"name":"NonExistentRamp","type":"error"},{"inputs":[],"name":"PermissionsError","type":"error"},{"inputs":[{"internalType":"address","name":"ramp","type":"address"}],"name":"RampAlreadyExists","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"SenderNotAllowed","type":"error"},{"inputs":[{"internalType":"uint256","name":"capacity","type":"uint256"},{"internalType":"uint256","name":"requested","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"TokenMaxCapacityExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"minWaitInSeconds","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"TokenRateLimitReached","type":"error"},{"inputs":[],"name":"ZeroAddressNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"}],"name":"AllowListAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"}],"name":"AllowListRemove","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Locked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"offRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"indexed":false,"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"name":"OffRampAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"offRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"indexed":false,"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"name":"OffRampConfigured","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"offRamp","type":"address"}],"name":"OffRampRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"onRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"indexed":false,"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"name":"OnRampAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"onRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"indexed":false,"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"name":"OnRampConfigured","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"onRamp","type":"address"}],"name":"OnRampRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"OwnershipTransferRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Released","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"removes","type":"address[]"},{"internalType":"address[]","name":"adds","type":"address[]"}],"name":"applyAllowListUpdates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"ramp","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"internalType":"struct TokenPool.RampUpdate[]","name":"onRamps","type":"tuple[]"},{"components":[{"internalType":"address","name":"ramp","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.Config","name":"rateLimiterConfig","type":"tuple"}],"internalType":"struct TokenPool.RampUpdate[]","name":"offRamps","type":"tuple[]"}],"name":"applyRampUpdates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"offRamp","type":"address"}],"name":"currentOffRampRateLimiterState","outputs":[{"components":[{"internalType":"uint128","name":"tokens","type":"uint128"},{"internalType":"uint32","name":"lastUpdated","type":"uint32"},{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.TokenBucket","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"onRamp","type":"address"}],"name":"currentOnRampRateLimiterState","outputs":[{"components":[{"internalType":"uint128","name":"tokens","type":"uint128"},{"internalType":"uint32","name":"lastUpdated","type":"uint32"},{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.TokenBucket","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllowList","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllowListEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getArmProxy","outputs":[{"internalType":"address","name":"armProxy","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOffRamps","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOnRamps","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"offRamp","type":"address"}],"name":"isOffRamp","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"onRamp","type":"address"}],"name":"isOnRamp","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"originalSender","type":"address"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint64","name":"","type":"uint64"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"lockOrBurn","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint64","name":"","type":"uint64"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"releaseOrMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"offRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.Config","name":"config","type":"tuple"}],"name":"setOffRampRateLimiterConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"onRamp","type":"address"},{"components":[{"internalType":"bool","name":"isEnabled","type":"bool"},{"internalType":"uint128","name":"capacity","type":"uint128"},{"internalType":"uint128","name":"rate","type":"uint128"}],"internalType":"struct RateLimiter.Config","name":"config","type":"tuple"}],"name":"setOnRampRateLimiterConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ 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.