Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/security/ReentrancyGuard.sol";
import "openzeppelin-contracts/contracts/security/Pausable.sol";
import "./interfaces/IBridgeData.sol";
import "./interfaces/IBridgeProxy.sol";
import "../libs/Utils.sol";
import "./interfaces/IReceiver.sol";

contract BridgeProxy is IBridgeProxy, Ownable, ReentrancyGuard {
    event Packet(
        address sender,
        uint256 nonce,
        uint16 dstChainID,
        bytes destination,
        bytes payload
    );
    event StoredPacket(
        uint64 srcChainID,
        bytes srcAddress,
        address dstAddress,
        uint256 nonce,
        bytes payload
    );

    address public logic;
    address public data;
    uint256 public nonce;

    function setData(address _data) external onlyOwner {
        require(data == address(0), "ALREADY_SET");
        data = _data;
    }

    function upgradeLogic(address _logic) external onlyOwner {
        logic = _logic;
    }

    function sendFromLogic(
        address sender,
        uint16 _dstChainID,
        bytes calldata _destination,
        bytes calldata _payload
    ) external nonReentrant {
        require(msg.sender == logic, "INVALID_SENDER");

        emit Packet(sender, nonce++, _dstChainID, _destination, _payload);
    }

    function receivePayloadFromLogic(
        uint16 _srcChainID,
        uint256 _nonce,
        bytes calldata _srcAddress,
        address _dstAddress,
        bytes calldata _payload,
        uint256 _gasLimit
    ) external nonReentrant {
        require(msg.sender == logic, "INVALID_SENDER");

        IBridgeData(data).markDoneFromProxy(_srcChainID, _nonce);

        require(
            IReceiver(_dstAddress).onReceive{gas: _gasLimit}(
                _srcChainID,
                _srcAddress,
                _nonce,
                _payload
            ),
            "ON_RECV"
        );

        emit StoredPacket(
            _srcChainID,
            _srcAddress,
            _dstAddress,
            _nonce,
            _payload
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

// 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: UNLICENSED
pragma solidity ^0.8.13;

interface IBridgeData {
    function isInWhiteListFrom(address _addr) external view returns (bool);

    function isInWhiteListTo(address _addr) external view returns (bool);

    function updateKeepersFromLogic(address[] calldata _newKeepers) external;

    function markDoneFromProxy(uint16 _srcChainID, uint256 _nonce) external;

    function getKeepers() external view returns (address[] memory);

    function chainID() external view returns (uint16);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

interface IBridgeProxy {
    function logic() external returns (address);

    function sendFromLogic(
        address sender,
        uint16 _dstChainID,
        bytes calldata _destination,
        bytes calldata _payload
    ) external;

    function receivePayloadFromLogic(
        uint16 _srcChainID,
        uint256 _nonce,
        bytes calldata _srcAddress,
        address _dstAddress,
        bytes calldata _payload,
        uint256 _gasLimit
    ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

interface IReceiver {
    function onReceive(
        uint16 _srcChainID,
        bytes calldata _srcAddress,
        uint256 _nonce,
        bytes calldata _payload
    ) external returns (bool);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

library Utils {
    function bytesToBytes32(
        bytes memory _bs
    ) internal pure returns (bytes32 value) {
        require(_bs.length == 32, "bytes length is not 32.");
        assembly {
            // load 32 bytes from memory starting from position _bs + 0x20 since the first 0x20 bytes stores _bs length
            value := mload(add(_bs, 0x20))
        }
    }

    function bytesToAddress(
        bytes memory _bs
    ) internal pure returns (address addr) {
        require(_bs.length == 20, "bytes length does not match address");
        assembly {
            // for _bs, first word store _bs.length, second word store _bs.value
            // load 32 bytes from mem[_bs+20], convert it into Uint160, meaning we take last 20 bytes as addr (address).
            addr := mload(add(_bs, 0x14)) // data within slot is lower-order aligned: https://stackoverflow.com/questions/66819732/state-variables-in-storage-lower-order-aligned-what-does-this-sentence-in-the
        }
    }

    function addressToBytes(
        address _addr
    ) internal pure returns (bytes memory bs) {
        assembly {
            bs := mload(0x40)
            mstore(bs, 0x14)
            mstore(add(bs, 0x20), shl(96, _addr))
            mstore(0x40, add(bs, 0x40))
        }
    }

    function sliceToBytes32(
        bytes memory _bytes,
        uint256 _start
    ) internal pure returns (bytes32 result) {
        require(_bytes.length >= (_start + 32));
        assembly {
            result := mload(add(add(_bytes, 0x20), _start))
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    ) internal pure returns (bytes memory tempBytes) {
        require(_bytes.length >= (_start + _length));

        assembly {
            switch iszero(_length)
            case 0 {
                tempBytes := mload(0x40)

                let lengthmod := and(_length, 31)
                let iz := iszero(lengthmod)

                let mc := add(add(tempBytes, lengthmod), mul(0x20, iz))
                let end := add(mc, _length)

                for {
                    let cc := add(
                        add(add(_bytes, lengthmod), mul(0x20, iz)),
                        _start
                    )
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }
                mstore(tempBytes, _length)
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }
    }

    function bytesToUint256(
        bytes memory _bs
    ) internal pure returns (uint256 value) {
        require(_bs.length == 32, "bytes length is not 32.");
        assembly {
            value := mload(add(_bs, 0x20))
        }
    }

    function uint256ToBytes(
        uint256 _value
    ) internal pure returns (bytes memory bs) {
        assembly {
            bs := mload(0x40)
            mstore(bs, 0x20)
            mstore(add(bs, 0x20), _value)

            mstore(0x40, add(bs, 0x40))
        }
    }

    function containMAddresses(
        address[] memory _keepers,
        address[] memory _signers,
        uint256 _m
    ) internal pure returns (bool) {
        uint256 m = 0;
        for (uint256 i = 0; i < _signers.length; i++) {
            for (uint256 j = 0; j < _keepers.length; j++) {
                if (_signers[i] == _keepers[j]) {
                    m++;
                    if (j < _keepers.length) {
                        _keepers[j] = _keepers[_keepers.length - 1];
                    }
                    assembly {
                        mstore(_keepers, sub(mload(_keepers), 1))
                    }
                    break;
                }
            }
        }

        return m >= _m;
    }

    uint256 constant SIGNATURE_LEN = 65;

    function verifySigs(
        bytes32 hash,
        bytes memory _sigs,
        address[] memory _keepers,
        uint256 _m
    ) internal pure returns (bool) {
        uint256 sigCount = _sigs.length / SIGNATURE_LEN;
        address[] memory signers = new address[](sigCount);
        bytes32 r;
        bytes32 s;
        uint8 v;
        for (uint256 i = 0; i < sigCount; i++) {
            r = sliceToBytes32(_sigs, i * SIGNATURE_LEN);
            s = sliceToBytes32(_sigs, i * SIGNATURE_LEN + 32);
            v = uint8(_sigs[i * SIGNATURE_LEN + 64]);
            signers[i] = ecrecover(hash, v, r, s);
            if (signers[i] == address(0)) {
                return false;
            }
        }

        return containMAddresses(_keepers, signers, _m);
    }

    function dedupAddress(
        address[] memory _dup
    ) internal pure returns (address[] memory) {
        address[] memory dedup = new address[](_dup.length);
        uint256 idx = 0;
        bool dup;
        for (uint256 i = 0; i < _dup.length; i++) {
            dup = false;
            for (uint256 j = 0; j < dedup.length; j++) {
                if (_dup[i] == dedup[j]) {
                    dup = true;
                    break;
                }
            }
            if (!dup) {
                dedup[idx] = _dup[i];
                idx += 1;
            }
        }
        assembly {
            mstore(dedup, idx)
        }

        return dedup;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    ) internal view returns (bool) {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(
                and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)),
                2
            )
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // fslot can contain both the length and contents of the array
                // if slength < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                // slength != 0
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {

                        } eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

[{"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":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"dstChainID","type":"uint16"},{"indexed":false,"internalType":"bytes","name":"destination","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"payload","type":"bytes"}],"name":"Packet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"srcChainID","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"srcAddress","type":"bytes"},{"indexed":false,"internalType":"address","name":"dstAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"payload","type":"bytes"}],"name":"StoredPacket","type":"event"},{"inputs":[],"name":"data","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"logic","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"_srcChainID","type":"uint16"},{"internalType":"uint256","name":"_nonce","type":"uint256"},{"internalType":"bytes","name":"_srcAddress","type":"bytes"},{"internalType":"address","name":"_dstAddress","type":"address"},{"internalType":"bytes","name":"_payload","type":"bytes"},{"internalType":"uint256","name":"_gasLimit","type":"uint256"}],"name":"receivePayloadFromLogic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint16","name":"_dstChainID","type":"uint16"},{"internalType":"bytes","name":"_destination","type":"bytes"},{"internalType":"bytes","name":"_payload","type":"bytes"}],"name":"sendFromLogic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_data","type":"address"}],"name":"setData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"}],"name":"upgradeLogic","outputs":[],"stateMutability":"nonpayable","type":"function"}]

0x608060405234801561001057600080fd5b506004361061009e5760003560e01c80638da5cb5b116100665780638da5cb5b14610116578063affed0e014610127578063d7dfa0dd1461013e578063f2fde38b14610151578063f63d13b51461016457600080fd5b806318fe378b146100a357806361dfdae6146100b8578063715018a6146100cb57806373d4a13a146100d3578063830fd8ac14610103575b600080fd5b6100b66100b136600461069d565b610177565b005b6100b66100c6366004610742565b61033f565b6100b66103b0565b6003546100e6906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b6100b6610111366004610764565b6103c4565b6000546001600160a01b03166100e6565b61013060045481565b6040519081526020016100fa565b6002546100e6906001600160a01b031681565b6100b661015f366004610742565b610480565b6100b6610172366004610742565b6104f9565b61017f610523565b6002546001600160a01b031633146101cf5760405162461bcd60e51b815260206004820152600e60248201526d24a72b20a624a22fa9a2a72222a960911b60448201526064015b60405180910390fd5b60035460405163055de76d60e11b815261ffff8a166004820152602481018990526001600160a01b0390911690630abbceda90604401600060405180830381600087803b15801561021f57600080fd5b505af1158015610233573d6000803e3d6000fd5b5050604051630d11a14560e31b81526001600160a01b038716925063688d0a289150839061026f908c908b908b908e908b908b9060040161081e565b60206040518083038160008887f115801561028e573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906102b39190610862565b6102e95760405162461bcd60e51b815260206004820152600760248201526627a72fa922a1ab60c91b60448201526064016101c6565b7f04189c8e297dfa45c50ce382f326442c8e364c5ba4a173d0838d425352ecb1b4888787878b88886040516103249796959493929190610884565b60405180910390a161033560018055565b5050505050505050565b61034761057c565b6003546001600160a01b03161561038e5760405162461bcd60e51b815260206004820152600b60248201526a1053149150511657d4d15560aa1b60448201526064016101c6565b600380546001600160a01b0319166001600160a01b0392909216919091179055565b6103b861057c565b6103c260006105d6565b565b6103cc610523565b6002546001600160a01b031633146104175760405162461bcd60e51b815260206004820152600e60248201526d24a72b20a624a22fa9a2a72222a960911b60448201526064016101c6565b600480547fcdb9fb741d82c65a081bb855b5e42174193549c537fd57a199609593827cff7191889190600061044b836108d9565b9190505587878787876040516104679796959493929190610900565b60405180910390a161047860018055565b505050505050565b61048861057c565b6001600160a01b0381166104ed5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016101c6565b6104f6816105d6565b50565b61050161057c565b600280546001600160a01b0319166001600160a01b0392909216919091179055565b6002600154036105755760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0060448201526064016101c6565b6002600155565b6000546001600160a01b031633146103c25760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016101c6565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b803561ffff8116811461063857600080fd5b919050565b60008083601f84011261064f57600080fd5b50813567ffffffffffffffff81111561066757600080fd5b60208301915083602082850101111561067f57600080fd5b9250929050565b80356001600160a01b038116811461063857600080fd5b60008060008060008060008060c0898b0312156106b957600080fd5b6106c289610626565b975060208901359650604089013567ffffffffffffffff808211156106e657600080fd5b6106f28c838d0161063d565b909850965086915061070660608c01610686565b955060808b013591508082111561071c57600080fd5b506107298b828c0161063d565b999c989b50969995989497949560a00135949350505050565b60006020828403121561075457600080fd5b61075d82610686565b9392505050565b6000806000806000806080878903121561077d57600080fd5b61078687610686565b955061079460208801610626565b9450604087013567ffffffffffffffff808211156107b157600080fd5b6107bd8a838b0161063d565b909650945060608901359150808211156107d657600080fd5b506107e389828a0161063d565b979a9699509497509295939492505050565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b61ffff8716815260806020820152600061083c6080830187896107f5565b85604084015282810360608401526108558185876107f5565b9998505050505050505050565b60006020828403121561087457600080fd5b8151801515811461075d57600080fd5b61ffff8816815260a0602082015260006108a260a08301888a6107f5565b6001600160a01b03871660408401526060830186905282810360808401526108cb8185876107f5565b9a9950505050505050505050565b6000600182016108f957634e487b7160e01b600052601160045260246000fd5b5060010190565b60018060a01b038816815286602082015261ffff8616604082015260a06060820152600061093260a0830186886107f5565b82810360808401526108cb8185876107f556fea2646970667358221220f6a3794ede4f3ed08adcfb39ebe2a0278b2e2ad0360deb83cf7c2c4de5a40b6c64736f6c634300080d0033