ETH Price: $3,785.61 (+1.04%)
Gas: 7 Gwei

Contract

0xee1DC6BCF1Ee967a350e9aC6CaaAA236109002ea
 

Overview

ETH Balance

27.802902467539846062 ETH

Eth Value

$105,250.97 (@ $3,785.61/ETH)

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Deposit180911182023-09-08 10:31:47257 days ago1694169107IN
0xee1DC6BC...6109002ea
0.75 ETH0.0004479515.98338033
Approve180862012023-09-07 18:01:23258 days ago1694109683IN
0xee1DC6BC...6109002ea
0 ETH0.0015197632.87614666
Withdraw180860182023-09-07 17:24:11258 days ago1694107451IN
0xee1DC6BC...6109002ea
0 ETH0.001413240.49296262
Deposit180860122023-09-07 17:22:59258 days ago1694107379IN
0xee1DC6BC...6109002ea
24.95290246 ETH0.0010262136.61637341
Transfer Ownersh...180804002023-09-06 22:32:35259 days ago1694039555IN
0xee1DC6BC...6109002ea
0 ETH0.0003522612.27016887
Approve180124942023-08-28 10:17:11268 days ago1693217831IN
0xee1DC6BC...6109002ea
0 ETH0.0007976117.25434474
Set Proposer180121062023-08-28 8:59:11268 days ago1693213151IN
0xee1DC6BC...6109002ea
0 ETH0.0010322221.59294614
Transfer179909492023-08-25 9:55:47271 days ago1692957347IN
0xee1DC6BC...6109002ea
0 ETH0.0008700116.85917616
Transfer179909432023-08-25 9:54:35271 days ago1692957275IN
0xee1DC6BC...6109002ea
0 ETH0.0005287517.80025916
Deposit179909032023-08-25 9:46:11271 days ago1692956771IN
0xee1DC6BC...6109002ea
2 ETH0.0007147815.83977159
Deposit179805852023-08-23 23:07:11273 days ago1692832031IN
0xee1DC6BC...6109002ea
0.1 ETH0.0009037320.02700273
0x60a03462179805542023-08-23 23:00:47273 days ago1692831647IN
 Create: BondToken
0 ETH0.0198251219.1630068

Latest 1 internal transaction

Advanced mode:
Parent Transaction Hash Block From To Value
180860182023-09-07 17:24:11258 days ago1694107451
0xee1DC6BC...6109002ea
10 wei
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
BondToken

Compiler Version
v0.8.18+commit.87f61d96

Optimization Enabled:
Yes with 1000000 runs

Other Settings:
default evmVersion
File 1 of 7 : BondToken.sol
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";

import "./interfaces/HubPoolInterface.sol";
import "./external/WETH9.sol";

interface ExtendedHubPoolInterface is HubPoolInterface {
    // Specify the automatically-implemented rootBundleProposal() getter.
    function rootBundleProposal() external pure returns (HubPoolInterface.RootBundle memory);
}

/**
 * @notice Across Bond Token (ABT).
 * ABT is a simple deposit contract based on WETH9. ABT is issued proportionally to any address that deposits Ether. It
 * imposes address-based permissioning on the WETH9 transferFrom() function in order to constrain the movement of ABT
 * into the Across v2 HubPool contract. When configured as the required HubPool bond token, ABT can dramatically reduce
 * the attack surface of the HubPool by requiring that addresses are explicitly approved before they can successfully
 * submit a root bundle proposal. The address-based permissioning does not constrain transfers that are needed to dispute
 * a root bundle proposal, so the ability of decentralised/unknown actors to dispute is unaffected.
 */
contract BondToken is WETH9, Ownable {
    using Address for address;

    ExtendedHubPoolInterface public immutable hubPool;

    /**
     * @notice Addresses that are permitted to make HubPool root bundle proposals.
     */
    mapping(address => bool) public proposers;

    /**
     * @notice Emitted on proposer permissions update.
     */
    event ProposerModified(address proposer, bool enabled);

    /**
     * @notice BondToken constructor.
     * @param _hubPool Address of the target HubPool contract.
     */
    constructor(ExtendedHubPoolInterface _hubPool) {
        name = "Across Bond Token";
        symbol = "ABT";
        hubPool = _hubPool;
    }

    /**
     * @notice Enable or disable an address as an allowed proposer. Emits a "ProposerModified" event on completion.
     * @param proposer Proposer address to modify.
     * @param enabled Boolean controlling whether the address is permitted to propose.
     */
    function setProposer(address proposer, bool enabled) external onlyOwner {
        proposers[proposer] = enabled;
        emit ProposerModified(proposer, enabled);
    }

    /**
     * @notice Transfer amt from src to dst. Prevents unauthorised root bundle proposals by blocking transfers to the
     * HubPool under the following conditions:
     * - The src address is not a pre-approved proposer, *and*
     * - The src address is the current proposer of a HubPool root bundle.
     * Falls back to the base implementation after verifying that the transfer is permitted.
     * @dev The require(..., "Transfer not permitted") statement is dependent on the internal ordering of HubPool
     * proposedRootBundle state variable updates, relative to calling bondToken.safeTransferFrom(). Changing the order
     * of HubPool actions may invalidate this verification. BondToken tests are implemented to detect this.
     * @param src Source address.
     * @param dst Destination address.
     * @param amt Amount to transfer.
     * @return True on success.
     */
    function transferFrom(
        address src,
        address dst,
        uint256 amt
    ) public override returns (bool) {
        if (dst == address(hubPool)) {
            require(proposers[src] || hubPool.rootBundleProposal().proposer != src, "Transfer not permitted");
        }
        return super.transferFrom(src, dst, amt);
    }
}

File 2 of 7 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 3 of 7 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

File 4 of 7 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 5 of 7 : Context.sol
// 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;
    }
}

File 7 of 7 : WETH9.sol
// SPDX-License-Identifier: GPL-3.0-or-later

/**
 * Copyright (C) 2015, 2016, 2017 Dapphub
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Imported as at commit 33d01d471437e1ab6861e4545ea4bb3895fd4d74 from:
 * UMAprotocol/protocol/packages/core/contracts/financial-templates/common/WETH9.sol
 * Changes applied post-import:
 * - Corrected SPDX-License-Identifier & reinstated GPLv3 license header.
 * - Permit transferFrom() to be overridden by marking it virtual.
 */

pragma solidity ^0.8.0;

contract WETH9 {
    string public name = "Wrapped Ether";
    string public symbol = "WETH";
    uint8 public decimals = 18;

    event Approval(address indexed src, address indexed guy, uint256 wad);
    event Transfer(address indexed src, address indexed dst, uint256 wad);
    event Deposit(address indexed dst, uint256 wad);
    event Withdrawal(address indexed src, uint256 wad);

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    receive() external payable {
        deposit();
    }

    fallback() external payable {
        deposit();
    }

    function deposit() public payable {
        balanceOf[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }

    function withdraw(uint256 wad) public {
        require(balanceOf[msg.sender] >= wad);
        balanceOf[msg.sender] -= wad;
        payable(msg.sender).transfer(wad);
        emit Withdrawal(msg.sender, wad);
    }

    function totalSupply() public view returns (uint256) {
        return address(this).balance;
    }

    function approve(address guy, uint256 wad) public returns (bool) {
        allowance[msg.sender][guy] = wad;
        emit Approval(msg.sender, guy, wad);
        return true;
    }

    function transfer(address dst, uint256 wad) public returns (bool) {
        return transferFrom(msg.sender, dst, wad);
    }

    /**
     * @dev Local change: marked virtual to allow overriding.
     */
    function transferFrom(
        address src,
        address dst,
        uint256 wad
    ) public virtual returns (bool) {
        require(balanceOf[src] >= wad);

        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
            require(allowance[src][msg.sender] >= wad);
            allowance[src][msg.sender] -= wad;
        }

        balanceOf[src] -= wad;
        balanceOf[dst] += wad;

        emit Transfer(src, dst, wad);

        return true;
    }
}

File 8 of 7 : HubPoolInterface.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @notice Concise list of functions in HubPool implementation.
 */
interface HubPoolInterface {
    // This leaf is meant to be decoded in the HubPool to rebalance tokens between HubPool and SpokePool.
    struct PoolRebalanceLeaf {
        // This is used to know which chain to send cross-chain transactions to (and which SpokePool to send to).
        uint256 chainId;
        // Total LP fee amount per token in this bundle, encompassing all associated bundled relays.
        uint256[] bundleLpFees;
        // Represents the amount to push to or pull from the SpokePool. If +, the pool pays the SpokePool. If negative
        // the SpokePool pays the HubPool. There can be arbitrarily complex rebalancing rules defined offchain. This
        // number is only nonzero when the rules indicate that a rebalancing action should occur. When a rebalance does
        // occur, runningBalances must be set to zero for this token and netSendAmounts should be set to the previous
        // runningBalances + relays - deposits in this bundle. If non-zero then it must be set on the SpokePool's
        // RelayerRefundLeaf amountToReturn as -1 * this value to show if funds are being sent from or to the SpokePool.
        int256[] netSendAmounts;
        // This is only here to be emitted in an event to track a running unpaid balance between the L2 pool and the L1
        // pool. A positive number indicates that the HubPool owes the SpokePool funds. A negative number indicates that
        // the SpokePool owes the HubPool funds. See the comment above for the dynamics of this and netSendAmounts.
        int256[] runningBalances;
        // Used by data worker to mark which leaves should relay roots to SpokePools, and to otherwise organize leaves.
        // For example, each leaf should contain all the rebalance information for a single chain, but in the case where
        // the list of l1Tokens is very large such that they all can't fit into a single leaf that can be executed under
        // the block gas limit, then the data worker can use this groupIndex to organize them. Any leaves with
        // a groupIndex equal to 0 will relay roots to the SpokePool, so the data worker should ensure that only one
        // leaf for a specific chainId should have a groupIndex equal to 0.
        uint256 groupIndex;
        // Used as the index in the bitmap to track whether this leaf has been executed or not.
        uint8 leafId;
        // The bundleLpFees, netSendAmounts, and runningBalances are required to be the same length. They are parallel
        // arrays for the given chainId and should be ordered by the l1Tokens field. All whitelisted tokens with nonzero
        // relays on this chain in this bundle in the order of whitelisting.
        address[] l1Tokens;
    }

    // A data worker can optimistically store several merkle roots on this contract by staking a bond and calling
    // proposeRootBundle. By staking a bond, the data worker is alleging that the merkle roots all contain valid leaves
    // that can be executed later to:
    // - Send funds from this contract to a SpokePool or vice versa
    // - Send funds from a SpokePool to Relayer as a refund for a relayed deposit
    // - Send funds from a SpokePool to a deposit recipient to fulfill a "slow" relay
    // Anyone can dispute this struct if the merkle roots contain invalid leaves before the
    // challengePeriodEndTimestamp. Once the expiration timestamp is passed, executeRootBundle to execute a leaf
    // from the poolRebalanceRoot on this contract and it will simultaneously publish the relayerRefundRoot and
    // slowRelayRoot to a SpokePool. The latter two roots, once published to the SpokePool, contain
    // leaves that can be executed on the SpokePool to pay relayers or recipients.
    struct RootBundle {
        // Contains leaves instructing this contract to send funds to SpokePools.
        bytes32 poolRebalanceRoot;
        // Relayer refund merkle root to be published to a SpokePool.
        bytes32 relayerRefundRoot;
        // Slow relay merkle root to be published to a SpokePool.
        bytes32 slowRelayRoot;
        // This is a 1D bitmap, with max size of 256 elements, limiting us to 256 chainsIds.
        uint256 claimedBitMap;
        // Proposer of this root bundle.
        address proposer;
        // Number of pool rebalance leaves to execute in the poolRebalanceRoot. After this number
        // of leaves are executed, a new root bundle can be proposed
        uint8 unclaimedPoolRebalanceLeafCount;
        // When root bundle challenge period passes and this root bundle becomes executable.
        uint32 challengePeriodEndTimestamp;
    }

    // Each whitelisted L1 token has an associated pooledToken struct that contains all information used to track the
    // cumulative LP positions and if this token is enabled for deposits.
    struct PooledToken {
        // LP token given to LPs of a specific L1 token.
        address lpToken;
        // True if accepting new LP's.
        bool isEnabled;
        // Timestamp of last LP fee update.
        uint32 lastLpFeeUpdate;
        // Number of LP funds sent via pool rebalances to SpokePools and are expected to be sent
        // back later.
        int256 utilizedReserves;
        // Number of LP funds held in contract less utilized reserves.
        uint256 liquidReserves;
        // Number of LP funds reserved to pay out to LPs as fees.
        uint256 undistributedLpFees;
    }

    // Helper contracts to facilitate cross chain actions between HubPool and SpokePool for a specific network.
    struct CrossChainContract {
        address adapter;
        address spokePool;
    }

    function setPaused(bool pause) external;

    function emergencyDeleteProposal() external;

    function relaySpokePoolAdminFunction(uint256 chainId, bytes memory functionData) external;

    function setProtocolFeeCapture(address newProtocolFeeCaptureAddress, uint256 newProtocolFeeCapturePct) external;

    function setBond(IERC20 newBondToken, uint256 newBondAmount) external;

    function setLiveness(uint32 newLiveness) external;

    function setIdentifier(bytes32 newIdentifier) external;

    function setCrossChainContracts(
        uint256 l2ChainId,
        address adapter,
        address spokePool
    ) external;

    function enableL1TokenForLiquidityProvision(address l1Token) external;

    function disableL1TokenForLiquidityProvision(address l1Token) external;

    function addLiquidity(address l1Token, uint256 l1TokenAmount) external payable;

    function removeLiquidity(
        address l1Token,
        uint256 lpTokenAmount,
        bool sendEth
    ) external;

    function exchangeRateCurrent(address l1Token) external returns (uint256);

    function liquidityUtilizationCurrent(address l1Token) external returns (uint256);

    function liquidityUtilizationPostRelay(address l1Token, uint256 relayedAmount) external returns (uint256);

    function sync(address l1Token) external;

    function proposeRootBundle(
        uint256[] memory bundleEvaluationBlockNumbers,
        uint8 poolRebalanceLeafCount,
        bytes32 poolRebalanceRoot,
        bytes32 relayerRefundRoot,
        bytes32 slowRelayRoot
    ) external;

    function executeRootBundle(
        uint256 chainId,
        uint256 groupIndex,
        uint256[] memory bundleLpFees,
        int256[] memory netSendAmounts,
        int256[] memory runningBalances,
        uint8 leafId,
        address[] memory l1Tokens,
        bytes32[] memory proof
    ) external;

    function disputeRootBundle() external;

    function claimProtocolFeesCaptured(address l1Token) external;

    function setPoolRebalanceRoute(
        uint256 destinationChainId,
        address l1Token,
        address destinationToken
    ) external;

    function setDepositRoute(
        uint256 originChainId,
        uint256 destinationChainId,
        address originToken,
        bool depositsEnabled
    ) external;

    function poolRebalanceRoute(uint256 destinationChainId, address l1Token)
        external
        view
        returns (address destinationToken);

    function loadEthForL2Calls() external payable;
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract ExtendedHubPoolInterface","name":"_hubPool","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"src","type":"address"},{"indexed":true,"internalType":"address","name":"guy","type":"address"},{"indexed":false,"internalType":"uint256","name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"dst","type":"address"},{"indexed":false,"internalType":"uint256","name":"wad","type":"uint256"}],"name":"Deposit","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":"address","name":"proposer","type":"address"},{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"ProposerModified","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"src","type":"address"},{"indexed":true,"internalType":"address","name":"dst","type":"address"},{"indexed":false,"internalType":"uint256","name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"src","type":"address"},{"indexed":false,"internalType":"uint256","name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"guy","type":"address"},{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"hubPool","outputs":[{"internalType":"contract ExtendedHubPoolInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"proposers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"proposer","type":"address"},{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setProposer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"amt","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000c186fa914353c44b2e33ebe05f21846f1048beda

-----Decoded View---------------
Arg [0] : _hubPool (address): 0xc186fA914353c44b2E33eBE05f21846F1048bEda

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000c186fa914353c44b2e33ebe05f21846f1048beda


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
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.