Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: 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;
    }
}

// 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;
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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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

000000000000000000000000c186fa914353c44b2e33ebe05f21846f1048beda

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

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