Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function symbol()
•    - function decimals()
•    - function approve(address spender, uin ...
•    - function mint(address account, uint a ...
•    - function burn(address account, uint a ...
•    - function transferFrom(address sender, ...
• interface IInterestRateModel
•    - function systemRate(ILendingPair _pai ...
•    - function supplyRatePerBlock(ILendingP ...
•    - function borrowRatePerBlock(ILendingP ...
• interface IRewardDistribution
•    - function distributeReward(address _ac ...
•    - function setTotalRewardPerBlock(uint ...
•    - function migrateRewards(address _reci ...
•    - function addPool(
•    - function setReward(
• interface IController
•    - function interestRateModel()
•    - function rewardDistribution()
•    - function feeRecipient()
•    - function LIQ_MIN_HEALTH()
•    - function minBorrowUSD()
•    - function liqFeeSystem(address _token)
•    - function liqFeeCaller(address _token)
•    - function liqFeesTotal(address _token)
•    - function colFactor(address _token)
•    - function depositLimit(address _lendin ...
•    - function borrowLimit(address _lending ...
•    - function originFee(address _token)
•    - function depositsEnabled()
•    - function borrowingEnabled()
•    - function setFeeRecipient(address _fee ...
•    - function tokenPrice(address _token)
•    - function tokenSupported(address _toke ...
•    - function setRewardDistribution(addres ...
•    - function setInterestRateModel(address ...
•    - function setDepositLimit(address _pai ...
• interface ILendingPair
•    - function checkAccountHealth(address _ ...
•    - function accrueAccount(address _accou ...
•    - function accrue()
•    - function accountHealth(address _accou ...
•    - function totalDebt(address _token)
•    - function tokenA()
•    - function tokenB()
•    - function lpToken(address _token)
•    - function debtOf(address _account, add ...
•    - function pendingDebtTotal(address _to ...
•    - function pendingSupplyTotal(address _ ...
•    - function deposit(address _token, uint ...
•    - function withdraw(address _token, uin ...
•    - function borrow(address _token, uint ...
•    - function repay(address _token, uint _ ...
•    - function withdrawBorrow(address _toke ...
•    - function controller()
•    - function borrowBalance(
•    - function convertTokenValues(
• interface IFeeConverter
•    - function convert(
• interface IFeeRecipient
•    - function setFeeConverter(IFeeConverte ...
•  contract Ownable
•    - function isOwner()
•    - function transferOwnership(address _n ...
•    - function acceptOwnership()
• library BytesLib
•    - function concat(
•    - function concatStorage(bytes storage ...
•    - function slice(
•    - function toAddress(bytes memory _byte ...
•    - function toUint8(bytes memory _bytes, ...
•    - function toUint16(bytes memory _bytes ...
•    - function toUint32(bytes memory _bytes ...
•    - function toUint64(bytes memory _bytes ...
•    - function toUint96(bytes memory _bytes ...
•    - function toUint128(bytes memory _byte ...
•    - function toUint256(bytes memory _byte ...
•    - function toBytes32(bytes memory _byte ...
•    - function equal(bytes memory _preBytes ...
•    - function equalStorage(
•  contract FeeRecipient is Ownable, ... *
•    - function convert(
•    - function setFeeConverter(IFeeConverte ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-07-27
*/

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.6;

interface IERC20 {
  function totalSupply() external view returns (uint);
  function balanceOf(address account) external view returns (uint);
  function transfer(address recipient, uint256 amount) external returns (bool);
  function allowance(address owner, address spender) external view returns (uint);
  function symbol() external view returns (string memory);
  function decimals() external view returns (uint);
  function approve(address spender, uint amount) external returns (bool);
  function mint(address account, uint amount) external;
  function burn(address account, uint amount) external;
  function transferFrom(address sender, address recipient, uint amount) external returns (bool);
  event Transfer(address indexed from, address indexed to, uint value);
  event Approval(address indexed owner, address indexed spender, uint value);
}

interface IInterestRateModel {
  function systemRate(ILendingPair _pair, address _token) external view returns(uint);
  function supplyRatePerBlock(ILendingPair _pair, address _token) external view returns(uint);
  function borrowRatePerBlock(ILendingPair _pair, address _token) external view returns(uint);
}

interface IRewardDistribution {

  function distributeReward(address _account, address _token) external;
  function setTotalRewardPerBlock(uint _value) external;
  function migrateRewards(address _recipient, uint _amount) external;

  function addPool(
    address _pair,
    address _token,
    bool    _isSupply,
    uint    _points
  ) external;

  function setReward(
    address _pair,
    address _token,
    bool    _isSupply,
    uint    _points
  ) external;
}

interface IController {
  function interestRateModel() external view returns(IInterestRateModel);
  function rewardDistribution() external view returns(IRewardDistribution);
  function feeRecipient() external view returns(address);
  function LIQ_MIN_HEALTH() external view returns(uint);
  function minBorrowUSD() external view returns(uint);
  function liqFeeSystem(address _token) external view returns(uint);
  function liqFeeCaller(address _token) external view returns(uint);
  function liqFeesTotal(address _token) external view returns(uint);
  function colFactor(address _token) external view returns(uint);
  function depositLimit(address _lendingPair, address _token) external view returns(uint);
  function borrowLimit(address _lendingPair, address _token) external view returns(uint);
  function originFee(address _token) external view returns(uint);
  function depositsEnabled() external view returns(bool);
  function borrowingEnabled() external view returns(bool);
  function setFeeRecipient(address _feeRecipient) external;
  function tokenPrice(address _token) external view returns(uint);
  function tokenSupported(address _token) external view returns(bool);
  function setRewardDistribution(address _value) external;
  function setInterestRateModel(address _value) external;
  function setDepositLimit(address _pair, address _token, uint _value) external;
}

interface ILendingPair {
  function checkAccountHealth(address _account) external view;
  function accrueAccount(address _account) external;
  function accrue() external;
  function accountHealth(address _account) external view returns(uint);
  function totalDebt(address _token) external view returns(uint);
  function tokenA() external view returns(address);
  function tokenB() external view returns(address);
  function lpToken(address _token) external view returns(IERC20);
  function debtOf(address _account, address _token) external view returns(uint);
  function pendingDebtTotal(address _token) external view returns(uint);
  function pendingSupplyTotal(address _token) external view returns(uint);
  function deposit(address _token, uint _amount) external;
  function withdraw(address _token, uint _amount) external;
  function borrow(address _token, uint _amount) external;
  function repay(address _token, uint _amount) external;
  function withdrawBorrow(address _token, uint _amount) external;
  function controller() external view returns(IController);

  function borrowBalance(
    address _account,
    address _borrowedToken,
    address _returnToken
  ) external view returns(uint);

  function convertTokenValues(
    address _fromToken,
    address _toToken,
    uint    _inputAmount
  ) external view returns(uint);
}

interface IFeeConverter {

  function convert(
    address          _incentiveRecipient,
    ILendingPair     _pair,
    bytes memory     _path,
    uint             _supplyTokenAmount,
    uint             _minWildOutput
  ) external returns(uint);
}

interface IFeeRecipient {
  function setFeeConverter(IFeeConverter _value) external;
}

contract Ownable {

  address public owner;
  address public pendingOwner;

  event OwnershipTransferInitiated(address indexed previousOwner, address indexed newOwner);
  event OwnershipTransferConfirmed(address indexed previousOwner, address indexed newOwner);

  constructor() {
    owner = msg.sender;
    emit OwnershipTransferConfirmed(address(0), owner);
  }

  modifier onlyOwner() {
    require(isOwner(), "Ownable: caller is not the owner");
    _;
  }

  function isOwner() public view returns (bool) {
    return msg.sender == owner;
  }

  function transferOwnership(address _newOwner) external onlyOwner {
    require(_newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferInitiated(owner, _newOwner);
    pendingOwner = _newOwner;
  }

  function acceptOwnership() external {
    require(msg.sender == pendingOwner, "Ownable: caller is not pending owner");
    emit OwnershipTransferConfirmed(owner, pendingOwner);
    owner = pendingOwner;
    pendingOwner = address(0);
  }
}

library BytesLib {

    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            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)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

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

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                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)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

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

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // 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

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    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)
            // Decode the length of the stored array like in concatStorage().
            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 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                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(uint256(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;
    }
}

contract FeeRecipient is Ownable, IFeeRecipient {

  using BytesLib for bytes;

  IFeeConverter public feeConverter;

  event FeeDistribution(uint amount);

  constructor(IFeeConverter _feeConverter) {
    feeConverter = _feeConverter;
  }

  function convert(
    ILendingPair _pair,
    bytes memory _path,
    uint _minWildOutput
  ) external {

    IERC20 lpToken = IERC20(_pair.lpToken(_path.toAddress(0)));
    uint supplyTokenAmount = lpToken.balanceOf(address(this));
    lpToken.transfer(address(feeConverter), supplyTokenAmount);
    uint distributedFees = feeConverter.convert(msg.sender, _pair, _path, supplyTokenAmount, _minWildOutput);

    emit FeeDistribution(distributedFees);
  }

  function setFeeConverter(IFeeConverter _value) external override onlyOwner {
    feeConverter = _value;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IFeeConverter","name":"_feeConverter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeDistribution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferConfirmed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferInitiated","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ILendingPair","name":"_pair","type":"address"},{"internalType":"bytes","name":"_path","type":"bytes"},{"internalType":"uint256","name":"_minWildOutput","type":"uint256"}],"name":"convert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeConverter","outputs":[{"internalType":"contract IFeeConverter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IFeeConverter","name":"_value","type":"address"}],"name":"setFeeConverter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000088a073d09c9f2041092a72ed288c19ae5da3f098

-----Decoded View---------------
Arg [0] : _feeConverter (address): 0x88A073d09c9F2041092a72ed288C19ae5dA3f098

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000088a073d09c9f2041092a72ed288c19ae5da3f098

25353:839:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5696:242;;;:::i;:::-;;25608:466;;;;;;:::i;:::-;;:::i;4901:20::-;;;;;-1:-1:-1;;;;;4901:20:0;;;;;;-1:-1:-1;;;;;2592:32:1;;;2574:51;;2562:2;2547:18;4901:20:0;;;;;;;;5360:85;5400:4;5434:5;-1:-1:-1;;;;;5434:5:0;5420:10;:19;5360:85;;4046:14:1;;4039:22;4021:41;;4009:2;3994:18;5360:85:0;3976:92:1;25439:33:0;;;;;-1:-1:-1;;;;;25439:33:0;;;26080:109;;;;;;:::i;:::-;;:::i;4926:27::-;;;;;-1:-1:-1;;;;;4926:27:0;;;5451:239;;;;;;:::i;:::-;;:::i;5696:242::-;5761:12;;-1:-1:-1;;;;;5761:12:0;5747:10;:26;5739:75;;;;-1:-1:-1;;;5739:75:0;;5622:2:1;5739:75:0;;;5604:21:1;5661:2;5641:18;;;5634:30;5700:34;5680:18;;;5673:62;-1:-1:-1;;;5751:18:1;;;5744:34;5795:19;;5739:75:0;;;;;;;;;5860:12;;;5853:5;;5826:47;;-1:-1:-1;;;;;5860:12:0;;;;5853:5;;;;5826:47;;;5888:12;;;;5880:20;;-1:-1:-1;;;;;;5880:20:0;;;-1:-1:-1;;;;;5888:12:0;;5880:20;;;;5907:25;;;5696:242::o;25608:466::-;25724:14;-1:-1:-1;;;;;25748:13:0;;;25762:18;:5;25724:14;25762:15;:18::i;:::-;25748:33;;-1:-1:-1;;;;;;25748:33:0;;;;;;;-1:-1:-1;;;;;2592:32:1;;;25748:33:0;;;2574:51:1;2547:18;;25748:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25814:32;;-1:-1:-1;;;25814:32:0;;25840:4;25814:32;;;2574:51:1;25724:58:0;;-1:-1:-1;25789:22:0;;-1:-1:-1;;;;;25814:17:0;;;;;2547:18:1;;25814:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25878:12;;25853:58;;-1:-1:-1;;;25853:58:0;;-1:-1:-1;;;;;25878:12:0;;;25853:58;;;3776:51:1;3843:18;;;3836:34;;;25789:57:0;;-1:-1:-1;25853:16:0;;;;;3749:18:1;;25853:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;25941:12:0;;:81;;-1:-1:-1;;;25941:81:0;;25918:20;;-1:-1:-1;;;;;25941:12:0;;:20;;:81;;25962:10;;25974:5;;25981;;25988:17;;26007:14;;25941:81;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25918:104;;26036:32;26052:15;26036:32;;;;5971:25:1;;5959:2;5944:18;;5926:76;26036:32:0;;;;;;;;25715:359;;;25608:466;;;:::o;26080:109::-;5400:4;5434:5;-1:-1:-1;;;;;5434:5:0;5420:10;:19;5286:54;;;;-1:-1:-1;;;5286:54:0;;4911:2:1;5286:54:0;;;4893:21:1;;;4930:18;;;4923:30;4989:34;4969:18;;;4962:62;5041:18;;5286:54:0;4883:182:1;5286:54:0;26162:12:::1;:21:::0;;-1:-1:-1;;;;;;26162:21:0::1;-1:-1:-1::0;;;;;26162:21:0;;;::::1;::::0;;;::::1;::::0;;26080:109::o;5451:239::-;5400:4;5434:5;-1:-1:-1;;;;;5434:5:0;5420:10;:19;5286:54;;;;-1:-1:-1;;;5286:54:0;;4911:2:1;5286:54:0;;;4893:21:1;;;4930:18;;;4923:30;4989:34;4969:18;;;4962:62;5041:18;;5286:54:0;4883:182:1;5286:54:0;-1:-1:-1;;;;;5531:23:0;::::1;5523:74;;;::::0;-1:-1:-1;;;5523:74:0;;4504:2:1;5523:74:0::1;::::0;::::1;4486:21:1::0;4543:2;4523:18;;;4516:30;4582:34;4562:18;;;4555:62;-1:-1:-1;;;4633:18:1;;;4626:36;4679:19;;5523:74:0::1;4476:228:1::0;5523:74:0::1;5636:5;::::0;;5609:44:::1;::::0;-1:-1:-1;;;;;5609:44:0;;::::1;::::0;5636:5;::::1;::::0;5609:44:::1;::::0;::::1;5660:12;:24:::0;;-1:-1:-1;;;;;;5660:24:0::1;-1:-1:-1::0;;;;;5660:24:0;;;::::1;::::0;;;::::1;::::0;;5451:239::o;18129:363::-;18208:7;18253:11;:6;18262:2;18253:11;:::i;:::-;18236:6;:13;:28;;18228:62;;;;-1:-1:-1;;;18228:62:0;;5272:2:1;18228:62:0;;;5254:21:1;5311:2;5291:18;;;5284:30;-1:-1:-1;;;5330:18:1;;;5323:51;5391:18;;18228:62:0;5244:171:1;18228:62:0;-1:-1:-1;18382:30:0;18398:4;18382:30;18376:37;-1:-1:-1;;;18372:71:0;;;18129:363::o;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;142:1;139;132:12;94:2;181:9;168:23;200:31;225:5;200:31;:::i;:::-;250:5;84:177;-1:-1:-1;;;84:177:1:o;266:277::-;333:6;386:2;374:9;365:7;361:23;357:32;354:2;;;402:1;399;392:12;354:2;434:9;428:16;487:5;480:13;473:21;466:5;463:32;453:2;;509:1;506;499:12;548:264;631:6;684:2;672:9;663:7;659:23;655:32;652:2;;;700:1;697;690:12;652:2;732:9;726:16;751:31;776:5;751:31;:::i;1090:1144::-;1196:6;1204;1212;1265:2;1253:9;1244:7;1240:23;1236:32;1233:2;;;1281:1;1278;1271:12;1233:2;1320:9;1307:23;1339:31;1364:5;1339:31;:::i;:::-;1389:5;-1:-1:-1;1445:2:1;1430:18;;1417:32;1468:18;1498:14;;;1495:2;;;1525:1;1522;1515:12;1495:2;1563:6;1552:9;1548:22;1538:32;;1608:7;1601:4;1597:2;1593:13;1589:27;1579:2;;1630:1;1627;1620:12;1579:2;1666;1653:16;1688:2;1684;1681:10;1678:2;;;1694:18;;:::i;:::-;1769:2;1763:9;1737:2;1823:13;;-1:-1:-1;;1819:22:1;;;1843:2;1815:31;1811:40;1799:53;;;1867:18;;;1887:22;;;1864:46;1861:2;;;1913:18;;:::i;:::-;1953:10;1949:2;1942:22;1988:2;1980:6;1973:18;2028:7;2023:2;2018;2014;2010:11;2006:20;2003:33;2000:2;;;2049:1;2046;2039:12;2000:2;2105;2100;2096;2092:11;2087:2;2079:6;2075:15;2062:46;2150:1;2145:2;2140;2132:6;2128:15;2124:24;2117:35;2171:6;2161:16;;;;;;;2224:2;2213:9;2209:18;2196:32;2186:42;;1223:1011;;;;;:::o;2239:184::-;2309:6;2362:2;2350:9;2341:7;2337:23;2333:32;2330:2;;;2378:1;2375;2368:12;2330:2;-1:-1:-1;2401:16:1;;2320:103;-1:-1:-1;2320:103:1:o;2636:961::-;2878:4;2924:1;2920;2915:3;2911:11;2907:19;2965:2;2957:6;2953:15;2942:9;2935:34;2988:2;3038;3030:6;3026:15;3021:2;3010:9;3006:18;2999:43;3078:3;3073:2;3062:9;3058:18;3051:31;3111:6;3105:13;3091:27;;3155:6;3149:3;3138:9;3134:19;3127:35;3180:1;3190:141;3204:6;3201:1;3198:13;3190:141;;;3300:14;;;3296:23;;3290:30;3265:17;;;3284:3;3261:27;3254:67;3219:10;;3190:141;;;3349:6;3346:1;3343:13;3340:2;;;3420:1;3414:3;3405:6;3394:9;3390:22;3386:32;3379:43;3340:2;-1:-1:-1;;3535:2:1;3520:18;;3513:34;;;;-1:-1:-1;3578:3:1;3563:19;;3556:35;;;;3500:3;3493:2;3472:15;;;-1:-1:-1;;3468:29:1;3453:45;3449:55;;;-1:-1:-1;;;2887:710:1:o;6007:225::-;6047:3;6078:1;6074:6;6071:1;6068:13;6065:2;;;6123:10;6118:3;6114:20;6111:1;6104:31;6158:4;6155:1;6148:15;6186:4;6183:1;6176:15;6065:2;-1:-1:-1;6217:9:1;;6055:177::o;6237:127::-;6298:10;6293:3;6289:20;6286:1;6279:31;6329:4;6326:1;6319:15;6353:4;6350:1;6343:15;6369:131;-1:-1:-1;;;;;6444:31:1;;6434:42;;6424:2;;6490:1;6487;6480:12;6424:2;6414:86;:::o

ipfs://df7c58c93ac4dd43197a1cff41abbf46d138a875ec24040995973b53f0595d31