// File: src/contracts/Erc20ConversionProxy.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './ChainlinkConversionPath.sol';
import './interfaces/ERC20FeeProxy.sol';
import '@openzeppelin/contracts/access/Ownable.sol';

/**
 * @title Erc20ConversionProxy
 * @notice This contract convert from chainlink then swaps ERC20 tokens
 *         before paying a request thanks to a conversion payment proxy
 */
contract Erc20ConversionProxy is Ownable {
    address public paymentProxy;
    ChainlinkConversionPath public chainlinkConversionPath;

    constructor(address _paymentProxyAddress, address _chainlinkConversionPathAddress) {
        paymentProxy = _paymentProxyAddress;
        chainlinkConversionPath = ChainlinkConversionPath(_chainlinkConversionPathAddress);
    }

    // Event to declare a conversion with a reference
    event TransferWithConversionAndReference(
        uint256 amount,
        address currency,
        bytes indexed paymentReference,
        uint256 feeAmount,
        uint256 maxRateTimespan
    );

    // Event to declare a transfer with a reference
    event TransferWithReferenceAndFee(
        address tokenAddress,
        address to,
        uint256 amount,
        bytes indexed paymentReference,
        uint256 feeAmount,
        address feeAddress
    );

    /**
     * @notice Transfers ERC20 tokens with a reference with amount based on the request amount in fiat
     * @param _to Transfer recipient of the payement
     * @param _requestAmount Request amount
     * @param _path Conversion path
     * @param _paymentReference Reference of the payment related
     * @param _feeAmount The amount of the payment fee
     * @param _feeAddress The fee recipient
     * @param _maxToSpend Amount max that we can spend on the behalf of the user
     * @param _maxRateTimespan Max time span with the oldestrate, ignored if zero
     */
    function transferFromWithReferenceAndFee(
        address _to,
        uint256 _requestAmount,
        address[] calldata _path,
        bytes calldata _paymentReference,
        uint256 _feeAmount,
        address _feeAddress,
        uint256 _maxToSpend,
        uint256 _maxRateTimespan
    ) external {
        (uint256 amountToPay, uint256 amountToPayInFees) = getConversions(
            _path,
            _requestAmount,
            _feeAmount,
            _maxRateTimespan
        );

        require(
            amountToPay + amountToPayInFees <= _maxToSpend,
            'Amount to pay is over the user limit'
        );

        // Pay the request and fees
        (bool status, ) = paymentProxy.delegatecall(
            abi.encodeWithSignature(
                'transferFromWithReferenceAndFee(address,address,uint256,bytes,uint256,address)',
                // payment currency
                _path[_path.length - 1],
                _to,
                amountToPay,
                _paymentReference,
                amountToPayInFees,
                _feeAddress
            )
        );
        require(status, 'transferFromWithReferenceAndFee failed');

        // Event to declare a transfer with a reference
        emit TransferWithConversionAndReference(
            _requestAmount,
            // request currency
            _path[0],
            _paymentReference,
            _feeAmount,
            _maxRateTimespan
        );
    }

    function getConversions(
        address[] memory _path,
        uint256 _requestAmount,
        uint256 _feeAmount,
        uint256 _maxRateTimespan
    ) internal view returns (uint256 amountToPay, uint256 amountToPayInFees) {
        (uint256 rate, uint256 oldestTimestampRate, uint256 decimals) = chainlinkConversionPath
            .getRate(_path);

        // Check rate timespan
        require(
            _maxRateTimespan == 0 || block.timestamp - oldestTimestampRate <= _maxRateTimespan,
            'aggregator rate is outdated'
        );

        // Get the amount to pay in the crypto currency chosen
        amountToPay = (_requestAmount * rate) / decimals;
        amountToPayInFees = (_feeAmount * rate) / decimals;
    }

    /**
     * @notice Update the conversion path contract used to fetch conversions
     * @param _chainlinkConversionPathAddress address of the conversion path contract
     */
    function updateConversionPathAddress(address _chainlinkConversionPathAddress)
        external
        onlyOwner
    {
        chainlinkConversionPath = ChainlinkConversionPath(_chainlinkConversionPathAddress);
    }

    /**
     * @notice Update the conversion proxy used to process the payment
     * @param _paymentProxyAddress address of the ETH conversion proxy
     */
    function updateConversionProxyAddress(address _paymentProxyAddress) external onlyOwner {
        paymentProxy = _paymentProxyAddress;
    }
}

// File: src/contracts/ChainlinkConversionPath.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import './legacy_openzeppelin/contracts/access/roles/WhitelistAdminRole.sol';

interface ERC20fraction {
    function decimals() external view returns (uint8);
}

interface AggregatorFraction {
    function decimals() external view returns (uint8);

    function latestAnswer() external view returns (int256);

    function latestTimestamp() external view returns (uint256);
}

/**
 * @title ChainlinkConversionPath
 *
 * @notice ChainlinkConversionPath is a contract computing currency conversion rates based on Chainlink aggretators
 */
contract ChainlinkConversionPath is WhitelistAdminRole {
    uint256 constant PRECISION = 1e18;
    uint256 constant NATIVE_TOKEN_DECIMALS = 18;
    uint256 constant FIAT_DECIMALS = 8;
    address public nativeTokenHash;

    /**
     * @param _nativeTokenHash hash of the native token
     */
    constructor(address _nativeTokenHash) {
        nativeTokenHash = _nativeTokenHash;
    }

    // Mapping of Chainlink aggregators (input currency => output currency => contract address)
    // input & output currencies are the addresses of the ERC20 contracts OR the sha3("currency code")
    mapping(address => mapping(address => address)) public allAggregators;

    // declare a new aggregator
    event AggregatorUpdated(address _input, address _output, address _aggregator);

    /**
     * @notice Update an aggregator
     * @param _input address representing the input currency
     * @param _output address representing the output currency
     * @param _aggregator address of the aggregator contract
     */
    function updateAggregator(
        address _input,
        address _output,
        address _aggregator
    ) external onlyWhitelistAdmin {
        allAggregators[_input][_output] = _aggregator;
        emit AggregatorUpdated(_input, _output, _aggregator);
    }

    /**
     * @notice Update a list of aggregators
     * @param _inputs list of addresses representing the input currencies
     * @param _outputs list of addresses representing the output currencies
     * @param _aggregators list of addresses of the aggregator contracts
     */
    function updateAggregatorsList(
        address[] calldata _inputs,
        address[] calldata _outputs,
        address[] calldata _aggregators
    ) external onlyWhitelistAdmin {
        require(_inputs.length == _outputs.length, 'arrays must have the same length');
        require(_inputs.length == _aggregators.length, 'arrays must have the same length');

        // For every conversions of the path
        for (uint256 i; i < _inputs.length; i++) {
            allAggregators[_inputs[i]][_outputs[i]] = _aggregators[i];
            emit AggregatorUpdated(_inputs[i], _outputs[i], _aggregators[i]);
        }
    }

    /**
     * @notice Computes the conversion of an amount through a list of intermediate conversions
     * @param _amountIn Amount to convert
     * @param _path List of addresses representing the currencies for the intermediate conversions
     * @return result The result after all the conversions
     * @return oldestRateTimestamp The oldest timestamp of the path
     */
    function getConversion(uint256 _amountIn, address[] calldata _path)
        external
        view
        returns (uint256 result, uint256 oldestRateTimestamp)
    {
        (uint256 rate, uint256 timestamp, uint256 decimals) = getRate(_path);

        // initialize the result
        result = (_amountIn * rate) / decimals;

        oldestRateTimestamp = timestamp;
    }

    /**
     * @notice Computes the conversion rate from a list of currencies
     * @param _path List of addresses representing the currencies for the conversions
     * @return rate The rate
     * @return oldestRateTimestamp The oldest timestamp of the path
     * @return decimals of the conversion rate
     */
    function getRate(address[] memory _path)
        public
        view
        returns (
            uint256 rate,
            uint256 oldestRateTimestamp,
            uint256 decimals
        )
    {
        // initialize the result with 18 decimals (for more precision)
        rate = PRECISION;
        decimals = PRECISION;
        oldestRateTimestamp = block.timestamp;

        // For every conversion of the path
        for (uint256 i; i < _path.length - 1; i++) {
            (
                AggregatorFraction aggregator,
                bool reverseAggregator,
                uint256 decimalsInput,
                uint256 decimalsOutput
            ) = getAggregatorAndDecimals(_path[i], _path[i + 1]);

            // store the latest timestamp of the path
            uint256 currentTimestamp = aggregator.latestTimestamp();
            if (currentTimestamp < oldestRateTimestamp) {
                oldestRateTimestamp = currentTimestamp;
            }

            // get the rate of the current step
            uint256 currentRate = uint256(aggregator.latestAnswer());
            // get the number of decimals of the current rate
            uint256 decimalsAggregator = uint256(aggregator.decimals());

            // mul with the difference of decimals before the current rate computation (for more precision)
            if (decimalsAggregator > decimalsInput) {
                rate = rate * (10**(decimalsAggregator - decimalsInput));
            }
            if (decimalsAggregator < decimalsOutput) {
                rate = rate * (10**(decimalsOutput - decimalsAggregator));
            }

            // Apply the current rate (if path uses an aggregator in the reverse way, div instead of mul)
            if (reverseAggregator) {
                rate = (rate * (10**decimalsAggregator)) / currentRate;
            } else {
                rate = (rate * currentRate) / (10**decimalsAggregator);
            }

            // div with the difference of decimals AFTER the current rate computation (for more precision)
            if (decimalsAggregator < decimalsInput) {
                rate = rate / (10**(decimalsInput - decimalsAggregator));
            }
            if (decimalsAggregator > decimalsOutput) {
                rate = rate / (10**(decimalsAggregator - decimalsOutput));
            }
        }
    }

    /**
     * @notice Gets aggregators and decimals of two currencies
     * @param _input input Address
     * @param _output output Address
     * @return aggregator to get the rate between the two currencies
     * @return reverseAggregator true if the aggregator returned give the rate from _output to _input
     * @return decimalsInput decimals of _input
     * @return decimalsOutput decimals of _output
     */
    function getAggregatorAndDecimals(address _input, address _output)
        private
        view
        returns (
            AggregatorFraction aggregator,
            bool reverseAggregator,
            uint256 decimalsInput,
            uint256 decimalsOutput
        )
    {
        // Try to get the right aggregator for the conversion
        aggregator = AggregatorFraction(allAggregators[_input][_output]);
        reverseAggregator = false;

        // if no aggregator found we try to find an aggregator in the reverse way
        if (address(aggregator) == address(0x00)) {
            aggregator = AggregatorFraction(allAggregators[_output][_input]);
            reverseAggregator = true;
        }

        require(address(aggregator) != address(0x00), 'No aggregator found');

        // get the decimals for the two currencies
        decimalsInput = getDecimals(_input);
        decimalsOutput = getDecimals(_output);
    }

    /**
     * @notice Gets decimals from an address currency
     * @param _addr address to check
     * @return decimals number of decimals
     */
    function getDecimals(address _addr) private view returns (uint256 decimals) {
        // by default we assume it is fiat
        decimals = FIAT_DECIMALS;
        // if address is the hash of the ETH currency
        if (_addr == nativeTokenHash) {
            decimals = NATIVE_TOKEN_DECIMALS;
        } else if (isContract(_addr)) {
            // otherwise, we get the decimals from the erc20 directly
            decimals = ERC20fraction(_addr).decimals();
        }
    }

    /**
     * @notice Checks if an address is a contract
     * @param _addr Address to check
     * @return true if the address hosts a contract, false otherwise
     */
    function isContract(address _addr) private view returns (bool) {
        uint32 size;
        // solium-disable security/no-inline-assembly
        assembly {
            size := extcodesize(_addr)
        }
        return (size > 0);
    }
}

// File: src/contracts/interfaces/ERC20FeeProxy.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20FeeProxy {
  event TransferWithReferenceAndFee(
    address tokenAddress,
    address to,
    uint256 amount,
    bytes indexed paymentReference,
    uint256 feeAmount,
    address feeAddress
  );

  function transferFromWithReferenceAndFee(
    address _tokenAddress,
    address _to,
    uint256 _amount,
    bytes calldata _paymentReference,
    uint256 _feeAmount,
    address _feeAddress
    ) external;
}
// File: @openzeppelin/contracts/access/Ownable.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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);
    }
}

// File: src/contracts/legacy_openzeppelin/contracts/access/roles/WhitelistAdminRole.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import '@openzeppelin/contracts/utils/Context.sol';
import "../Roles.sol";

/**
 * @title WhitelistAdminRole
 * @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
 */
abstract contract WhitelistAdminRole is Context {
    using Roles for Roles.Role;

    event WhitelistAdminAdded(address indexed account);
    event WhitelistAdminRemoved(address indexed account);

    Roles.Role private _whitelistAdmins;

    constructor () {
        _addWhitelistAdmin(_msgSender());
    }

    modifier onlyWhitelistAdmin() {
        require(isWhitelistAdmin(_msgSender()), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
        _;
    }

    function isWhitelistAdmin(address account) public view returns (bool) {
        return _whitelistAdmins.has(account);
    }

    function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
        _addWhitelistAdmin(account);
    }

    function renounceWhitelistAdmin() public {
        _removeWhitelistAdmin(_msgSender());
    }

    function _addWhitelistAdmin(address account) internal {
        _whitelistAdmins.add(account);
        emit WhitelistAdminAdded(account);
    }

    function _removeWhitelistAdmin(address account) internal {
        _whitelistAdmins.remove(account);
        emit WhitelistAdminRemoved(account);
    }
}

// File: @openzeppelin/contracts/utils/Context.sol



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

pragma solidity ^0.8.0;

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

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

// File: src/contracts/legacy_openzeppelin/contracts/access/Roles.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}