ETH Price: $3,440.99 (+2.95%)
Gas: 52 Gwei

Contract

0x01Ce5b536e6629F3ABC664f7EF530108BcBb6A9B
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Set Arbitrageurs176639732023-07-10 14:52:23235 days ago1689000743IN
0x01Ce5b53...8BcBb6A9B
0 ETH0.0011228134.8820559
Set Arbitrageurs176639722023-07-10 14:52:11235 days ago1689000731IN
0x01Ce5b53...8BcBb6A9B
0 ETH0.0016683632.02915235
0x60806040171332952023-04-26 22:14:11310 days ago1682547251IN
 Create: ArbitrageurListExample
0 ETH0.0255879238.80192305

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ArbitrageurListExample

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, None license
/**
 *Submitted for verification at Etherscan.io on 2023-04-27
*/

/**
 * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are
 * supported.
 */
function _require(bool condition, uint256 errorCode) pure {
    if (!condition) _revert(errorCode);
}

/**
 * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported.
 */
function _revert(uint256 errorCode) pure {
    // We're going to dynamically create a revert string based on the error code, with the following format:
    // 'BAL#{errorCode}'
    // where the code is left-padded with zeroes to three digits (so they range from 000 to 999).
    //
    // We don't have revert strings embedded in the contract to save bytecode size: it takes much less space to store a
    // number (8 to 16 bits) than the individual string characters.
    //
    // The dynamic string creation algorithm that follows could be implemented in Solidity, but assembly allows for a
    // much denser implementation, again saving bytecode size. Given this function unconditionally reverts, this is a
    // safe place to rely on it without worrying about how its usage might affect e.g. memory contents.
    assembly {
        // First, we need to compute the ASCII representation of the error code. We assume that it is in the 0-999
        // range, so we only need to convert three digits. To convert the digits to ASCII, we add 0x30, the value for
        // the '0' character.

        let units := add(mod(errorCode, 10), 0x30)

        errorCode := div(errorCode, 10)
        let tenths := add(mod(errorCode, 10), 0x30)

        errorCode := div(errorCode, 10)
        let hundreds := add(mod(errorCode, 10), 0x30)

        // With the individual characters, we can now construct the full string. The "BAL#" part is a known constant
        // (0x42414c23): we simply shift this by 24 (to provide space for the 3 bytes of the error code), and add the
        // characters to it, each shifted by a multiple of 8.
        // The revert reason is then shifted left by 200 bits (256 minus the length of the string, 7 characters * 8 bits
        // per character = 56) to locate it in the most significant part of the 256 slot (the beginning of a byte
        // array).

        let revertReason := shl(200, add(0x42414c23000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))

        // We can now encode the reason in memory, which can be safely overwritten as we're about to revert. The encoded
        // message will have the following layout:
        // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]

        // The Solidity revert reason identifier is 0x08c739a0, the function selector of the Error(string) function. We
        // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.
        mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
        // Next is the offset to the location of the string, which will be placed immediately after (20 bytes away).
        mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
        // The string length is fixed: 7 characters.
        mstore(0x24, 7)
        // Finally, the string itself is stored.
        mstore(0x44, revertReason)

        // Even if the string is only 7 bytes long, we need to return a full 32 byte slot containing it. The length of
        // the encoded message is therefore 4 + 32 + 32 + 32 = 100.
        revert(0, 100)
    }
}

library Errors {
    // Math
    uint256 internal constant ADD_OVERFLOW = 0;
    uint256 internal constant SUB_OVERFLOW = 1;
    uint256 internal constant SUB_UNDERFLOW = 2;
    uint256 internal constant MUL_OVERFLOW = 3;
    uint256 internal constant ZERO_DIVISION = 4;
    uint256 internal constant DIV_INTERNAL = 5;
    uint256 internal constant X_OUT_OF_BOUNDS = 6;
    uint256 internal constant Y_OUT_OF_BOUNDS = 7;
    uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;
    uint256 internal constant INVALID_EXPONENT = 9;

    // Input
    uint256 internal constant OUT_OF_BOUNDS = 100;
    uint256 internal constant UNSORTED_ARRAY = 101;
    uint256 internal constant UNSORTED_TOKENS = 102;
    uint256 internal constant INPUT_LENGTH_MISMATCH = 103;
    uint256 internal constant ZERO_TOKEN = 104;

    // Shared pools
    uint256 internal constant MIN_TOKENS = 200;
    uint256 internal constant MAX_TOKENS = 201;
    uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;
    uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;
    uint256 internal constant MINIMUM_BPT = 204;
    uint256 internal constant CALLER_NOT_VAULT = 205;
    uint256 internal constant UNINITIALIZED = 206;
    uint256 internal constant BPT_IN_MAX_AMOUNT = 207;
    uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;
    uint256 internal constant EXPIRED_PERMIT = 209;

    // Pools
    uint256 internal constant MIN_AMP = 300;
    uint256 internal constant MAX_AMP = 301;
    uint256 internal constant MIN_WEIGHT = 302;
    uint256 internal constant MAX_STABLE_TOKENS = 303;
    uint256 internal constant MAX_IN_RATIO = 304;
    uint256 internal constant MAX_OUT_RATIO = 305;
    uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;
    uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;
    uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;
    uint256 internal constant INVALID_TOKEN = 309;
    uint256 internal constant UNHANDLED_JOIN_KIND = 310;
    uint256 internal constant ZERO_INVARIANT = 311;
    uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312;
    uint256 internal constant ORACLE_NOT_INITIALIZED = 313;
    uint256 internal constant ORACLE_QUERY_TOO_OLD = 314;
    uint256 internal constant ORACLE_INVALID_INDEX = 315;
    uint256 internal constant ORACLE_BAD_SECS = 316;

    // Lib
    uint256 internal constant REENTRANCY = 400;
    uint256 internal constant SENDER_NOT_ALLOWED = 401;
    uint256 internal constant PAUSED = 402;
    uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;
    uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;
    uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;
    uint256 internal constant INSUFFICIENT_BALANCE = 406;
    uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;
    uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;
    uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;
    uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;
    uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;
    uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;
    uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;
    uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;
    uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;
    uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;
    uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;
    uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;
    uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;
    uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;
    uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;
    uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;
    uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;
    uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;
    uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;

    // Vault
    uint256 internal constant INVALID_POOL_ID = 500;
    uint256 internal constant CALLER_NOT_POOL = 501;
    uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;
    uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;
    uint256 internal constant INVALID_SIGNATURE = 504;
    uint256 internal constant EXIT_BELOW_MIN = 505;
    uint256 internal constant JOIN_ABOVE_MAX = 506;
    uint256 internal constant SWAP_LIMIT = 507;
    uint256 internal constant SWAP_DEADLINE = 508;
    uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;
    uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;
    uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;
    uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;
    uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;
    uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;
    uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;
    uint256 internal constant INSUFFICIENT_ETH = 516;
    uint256 internal constant UNALLOCATED_ETH = 517;
    uint256 internal constant ETH_TRANSFER = 518;
    uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;
    uint256 internal constant TOKENS_MISMATCH = 520;
    uint256 internal constant TOKEN_NOT_REGISTERED = 521;
    uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;
    uint256 internal constant TOKENS_ALREADY_SET = 523;
    uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;
    uint256 internal constant NONZERO_TOKEN_BALANCE = 525;
    uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;
    uint256 internal constant POOL_NO_TOKENS = 527;
    uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;

    // Fees
    uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;
    uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;
    uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;
}

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _enterNonReentrant();
        _;
        _exitNonReentrant();
    }

    function _enterNonReentrant() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        _require(_status != _ENTERED, Errors.REENTRANCY);

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _exitNonReentrant() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

/// @notice Interface for managing list of addresses permitted to perform preferred rate
///         arbitrage swaps on Cron-Fi TWAMM V1.0.
///
interface IArbitrageurList {
  /// @param sender is the address that called the function changing list owner permissions.
  /// @param listOwner is the address to change list owner permissions on.
  /// @param permission is true if the address specified in listOwner is granted list owner
  ///        permissions. Is false otherwise.
  ///
  event ListOwnerPermissions(address indexed sender, address indexed listOwner, bool indexed permission);

  /// @param sender is the address that called the function changing arbitrageur permissions.
  /// @param arbitrageurs is a list of addresses to change arbitrage permissions on.
  /// @param permission is true if the addresses specified in arbitrageurs is granted
  ///        arbitrage permissions. Is false otherwise.
  ///
  event ArbitrageurPermissions(address indexed sender, address[] arbitrageurs, bool indexed permission);

  /// @param sender is the address that called the function changing the next list address.
  /// @param nextListAddress is the address the return value of the nextList function is set to.
  ///
  event NextList(address indexed sender, address indexed nextListAddress);

  /// @notice Returns true if the provide address is permitted the preferred
  ///         arbitrage rate in the partner swap method of a Cron-Fi TWAMM pool.
  ///         Returns false otherwise.
  /// @param _address the address to check for arbitrage rate permissions.
  ///
  function isArbitrageur(address _address) external returns (bool);

  /// @notice Returns the address of the next contract implementing the next list of arbitrageurs.
  ///         If the return value is the NULL address, address(0), then the TWAMM contract's update
  ///         list method will keep the existing address it is storing to check for arbitrage permissions.
  ///
  function nextList() external returns (address);
}

// (c) Copyright 2022, Bad Pumpkin Inc. All Rights Reserved
//
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.7.6;

address constant NULL_ADDR = address(0);

/// @notice Abstract contract for managing list of addresses permitted to perform preferred rate
///         arbitrage swaps on Cron-Fi TWAMM V1.0.
///
/// @dev    In Cron-Fi TWAMM V1.0 pools, the partner swap (preferred rate arbitrage swap) may only
///         be successfully called by an address that returns true when isArbitrageur in a contract
///         derived from this one (the caller must also specify the address of the arbitrage partner
///         to facilitate a call to isArbitrageur in the correct contract).
///
/// @dev    Two mechanisms are provided for updating the arbitrageur list, they are:
///             - The setArbitrageurs method, which allows a list of addresses to
///               be given or removed arbitrage permission.
///             - The nextList mechanism. In order to use this mechanism, a new contract deriving
///               from this contract with new arbitrage addresses specified must be deployed.
///               A listOwner then sets the nextList address to the newly deployed contract
///               address with the setNextList method.
///               Finally, the arbPartner address in the corresponding Cron-Fi TWAMM contract will
///               then call updateArbitrageList to retrieve the new arbitrageur list contract address
///               from this contract instance. Note that all previous arbitraguer contracts in the TWAMM
///               contract using the updated list are ignored.
///
/// @dev    Note that this is a bare-bones implementation without conveniences like a list to
///         inspect all current arbitraguer addresses at once (emitted events can be consulted and
///         aggregated off-chain for this purpose), however users are encouraged to modify the contract
///         as they wish as long as the following methods continue to function as specified:
///             - isArbitrageur
contract ArbitrageurListExample is IArbitrageurList, ReentrancyGuard {
  mapping(address => bool) private listOwners;
  mapping(address => bool) private permittedAddressMap;
  address public override(IArbitrageurList) nextList;

  modifier senderIsListOwner() {
    require(listOwners[msg.sender], "Sender must be listOwner");
    _;
  }

  /// @notice Constructs this contract with next contract and the specified list of addresses permitted
  ///         to arbitrage.
  /// @param _arbitrageurs is a list of addresses to give arbitrage permission to on contract instantiation.
  ///
  constructor(address[] memory _arbitrageurs) {
    bool permitted = true;

    listOwners[msg.sender] = permitted;
    emit ListOwnerPermissions(msg.sender, msg.sender, permitted);

    setArbitrageurs(_arbitrageurs, permitted);
    emit ArbitrageurPermissions(msg.sender, _arbitrageurs, permitted);

    nextList = NULL_ADDR;
  }

  /// @notice Sets whether or not a specified address is a list owner.
  /// @param _address is the address to give or remove list owner priviliges from.
  /// @param _permitted if true, gives the specified address list owner priviliges. If false
  ///        removes list owner priviliges.
  function setListOwner(address _address, bool _permitted) public nonReentrant senderIsListOwner {
    listOwners[_address] = _permitted;

    emit ListOwnerPermissions(msg.sender, _address, _permitted);
  }

  /// @notice Sets whether the specified list of addresses is permitted to arbitrage Cron-Fi TWAMM
  ///         pools at a preffered rate or not.
  /// @param _arbitrageurs is a list of addresses to add or remove arbitrage permission from.
  /// @param _permitted specifies if the list of addresses contained in _arbitrageurs will be given
  ///        arbitrage permission when set to true. When false, arbitrage permission is removed from
  ///        the specified addresses.
  function setArbitrageurs(address[] memory _arbitrageurs, bool _permitted) public nonReentrant senderIsListOwner {
    uint256 length = _arbitrageurs.length;
    for (uint256 index = 0; index < length; index++) {
      permittedAddressMap[_arbitrageurs[index]] = _permitted;
    }

    emit ArbitrageurPermissions(msg.sender, _arbitrageurs, _permitted);
  }

  /// @notice Sets the next contract address to use for arbitraguer permissions. Requires that the
  ///         contract be instantiated and that a call to updateArbitrageList is made by the
  ///         arbitrage partner list on the corresponding TWAMM pool.
  /// @param _address is the address of the instantiated contract deriving from this contract to
  ///        use for address arbitrage permissions.
  function setNextList(address _address) public nonReentrant senderIsListOwner {
    nextList = _address;

    emit NextList(msg.sender, _address);
  }

  /// @notice Returns true if specified address has list owner permissions.
  /// @param _address is the address to check for list owner permissions.
  function isListOwner(address _address) public view returns (bool) {
    return listOwners[_address];
  }

  /// @notice Returns true if the provide address is permitted the preferred
  ///         arbitrage rate in the partner swap method of a Cron-Fi TWAMM pool.
  ///         Returns false otherwise.
  /// @param _address the address to check for arbitrage rate permissions.
  ///
  function isArbitrageur(address _address) public view override(IArbitrageurList) returns (bool) {
    return permittedAddressMap[_address];
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address[]","name":"_arbitrageurs","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address[]","name":"arbitrageurs","type":"address[]"},{"indexed":true,"internalType":"bool","name":"permission","type":"bool"}],"name":"ArbitrageurPermissions","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"listOwner","type":"address"},{"indexed":true,"internalType":"bool","name":"permission","type":"bool"}],"name":"ListOwnerPermissions","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"nextListAddress","type":"address"}],"name":"NextList","type":"event"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isArbitrageur","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isListOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextList","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_arbitrageurs","type":"address[]"},{"internalType":"bool","name":"_permitted","type":"bool"}],"name":"setArbitrageurs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_permitted","type":"bool"}],"name":"setListOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setNextList","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106100625760003560e01c8063387f51771461006757806355fcff3c146100c15780638657fcec146100f55780639bb3dd54146101b9578063d16758f8146101fd578063da08252214610257575b600080fd5b6100a96004803603602081101561007d57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506102a7565b60405180821515815260200191505060405180910390f35b6100c96102fd565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6101b76004803603604081101561010b57600080fd5b810190808035906020019064010000000081111561012857600080fd5b82018360208201111561013a57600080fd5b8035906020019184602083028401116401000000008311171561015c57600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600081840152601f19601f820116905080830192505050505050509192919290803515159060200190929190505050610323565b005b6101fb600480360360208110156101cf57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610512565b005b61023f6004803603602081101561021357600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061067f565b60405180821515815260200191505060405180910390f35b6102a56004803603604081101561026d57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035151590602001909291905050506106d5565b005b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61032b61085c565b600160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff166103ea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f53656e646572206d757374206265206c6973744f776e6572000000000000000081525060200191505060405180910390fd5b60008251905060005b8181101561047257826002600086848151811061040c57fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555080806001019150506103f3565b508115153373ffffffffffffffffffffffffffffffffffffffff167fd2c06feec3db06ab48513bb19da9bbcb3502c169a4541d72f8ba1978a7e18b09856040518080602001828103825283818151815260200191508051906020019060200280838360005b838110156104f25780820151818401526020810190506104d7565b505050509050019250505060405180910390a35061050e610878565b5050565b61051a61085c565b600160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff166105d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f53656e646572206d757374206265206c6973744f776e6572000000000000000081525060200191505060405180910390fd5b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f53b37aa304bd976a8c03475f9cd006db4d7c0cb3ee6e1a7ac5cd4c992792c15860405160405180910390a361067c610878565b50565b6000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b6106dd61085c565b600160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff1661079c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260188152602001807f53656e646572206d757374206265206c6973744f776e6572000000000000000081525060200191505060405180910390fd5b80600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508015158273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f4fa6c4e2e05f8a35e3e89823974719b069b9ddb46a4223bf1b8bb7cdcdf84ede60405160405180910390a4610858610878565b5050565b61086e60026000541415610190610882565b6002600081905550565b6001600081905550565b816108915761089081610895565b5b5050565b6030600a820601600a820491506030600a830601600a830492506030600a8406018060101b8260081b8401016642414c230000000160c81b7f08c379a000000000000000000000000000000000000000000000000000000000600052602060045260076024528060445260646000fdfea2646970667358221220ffa4d2e0d5e87971d8971e7f18c3d5804114d22ebc6ee990af2432ef68f841e664736f6c63430007060033

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000965df5ff6116c395187e288e5c87fb96cfb8141c

-----Decoded View---------------
Arg [0] : _arbitrageurs (address[]): 0x965Df5Ff6116C395187E288e5C87fb96CfB8141c

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [2] : 000000000000000000000000965df5ff6116c395187e288e5c87fb96cfb8141c


Deployed Bytecode Sourcemap

16472:3581:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19906:144;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;16651:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;18415:363;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;19200:153;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;19511:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;17714:209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;19906:144;19995:4;20015:19;:29;20035:8;20015:29;;;;;;;;;;;;;;;;;;;;;;;;;20008:36;;19906:144;;;:::o;16651:50::-;;;;;;;;;;;;;:::o;18415:363::-;11753:20;:18;:20::i;:::-;16752:10:::1;:22;16763:10;16752:22;;;;;;;;;;;;;;;;;;;;;;;;;16744:59;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;18534:14:::2;18551:13;:20;18534:37;;18583:13;18578:120;18610:6;18602:5;:14;18578:120;;;18680:10;18636:19;:41;18656:13;18670:5;18656:20;;;;;;;;;;;;;;18636:41;;;;;;;;;;;;;;;;:54;;;;;;;;;;;;;;;;;;18618:7;;;;;;;18578:120;;;;18761:10;18711:61;;18734:10;18711:61;;;18746:13;18711:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16810:1;11796:19:::0;:17;:19::i;:::-;18415:363;;:::o;19200:153::-;11753:20;:18;:20::i;:::-;16752:10:::1;:22;16763:10;16752:22;;;;;;;;;;;;;;;;;;;;;;;;;16744:59;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;19295:8:::2;19284;;:19;;;;;;;;;;;;;;;;;;19338:8;19317:30;;19326:10;19317:30;;;;;;;;;;;;11796:19:::0;:17;:19::i;:::-;19200:153;:::o;19511:106::-;19571:4;19591:10;:20;19602:8;19591:20;;;;;;;;;;;;;;;;;;;;;;;;;19584:27;;19511:106;;;:::o;17714:209::-;11753:20;:18;:20::i;:::-;16752:10:::1;:22;16763:10;16752:22;;;;;;;;;;;;;;;;;;;;;;;;;16744:59;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;17839:10:::2;17816;:20;17827:8;17816:20;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;17906:10;17863:54;;17896:8;17863:54;;17884:10;17863:54;;;;;;;;;;;;11796:19:::0;:17;:19::i;:::-;17714:209;;:::o;11831:277::-;11956:48;11237:1;11965:7;;:19;;6001:3;11956:8;:48::i;:::-;11237:1;12082:7;:18;;;;11831:277::o;12116:212::-;11193:1;12298:7;:22;;;;12116:212::o;137:103::-;207:9;202:34;;218:18;226:9;218:7;:18::i;:::-;202:34;137:103;;:::o;352:3223::-;1509:4;1504:2;1493:9;1489:18;1485:29;1554:2;1543:9;1539:18;1526:31;;1605:4;1600:2;1589:9;1585:18;1581:29;1650:2;1639:9;1635:18;1622:31;;1703:4;1698:2;1687:9;1683:18;1679:29;2370:8;2366:2;2362:17;2352:6;2349:1;2345:14;2338:5;2334:26;2330:50;2312:16;2308:73;2303:3;2299:83;2910:66;2905:3;2898:79;3118:66;3112:4;3105:80;3262:1;3256:4;3249:15;3337:12;3331:4;3324:26;3561:3;3558:1;3551:14

Swarm Source

ipfs://ffa4d2e0d5e87971d8971e7f18c3d5804114d22ebc6ee990af2432ef68f841e6

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

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