Contract 0x08b1fc2b48e5871354af138b7909e9d1a04a89dd 2

//SPDX-License-Identifier: LICENSED

// Solidity files have to start with this pragma.
// It will be used by the Solidity compiler to validate its version.
pragma solidity ^0.7.0;
pragma abicoder v2;
// We import this library to be able to use console.log
// import "hardhat/console.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/PriceOracle.sol";
import "./interfaces/ILimitManager.sol";
import "./interfaces/ILevelManager.sol";
import "./interfaces/IMarketManager.sol";
import "./interfaces/ICashBackManager.sol";
import "./interfaces/IWETH9.sol";
import "./interfaces/ISwapper.sol";
import "./interfaces/ERC20Interface.sol";
import "./interfaces/IConverter.sol";
import "./libraries/SafeMath.sol";

import "./OwnerConstants.sol";
import "./SignerRole.sol";

// This is the main building block for smart contracts.
contract OkseCard is OwnerConstants, SignerRole {
    //  bytes4 public constant PAY_MONTHLY_FEE = bytes4(keccak256(bytes('payMonthlyFee')));
    bytes4 public constant PAY_MONTHLY_FEE = 0x529a8d6c;
    //  bytes4 public constant WITHDRAW = bytes4(keccak256(bytes('withdraw')));
    bytes4 public constant WITHDRAW = 0x855511cc;
    //  bytes4 public constant BUYGOODS = bytes4(keccak256(bytes('buyGoods')));
    bytes4 public constant BUYGOODS = 0xa8fd19f2;
    //  bytes4 public constant SET_USER_MAIN_MARKET = bytes4(keccak256(bytes('setUserMainMarket')));
    bytes4 public constant SET_USER_MAIN_MARKET = 0x4a22142e;

    // uint256 public constant CARD_VALIDATION_TIME = 10 minutes; // 30 days in prodcution
    uint256 public constant CARD_VALIDATION_TIME = 30 days; // 30 days in prodcution

    using SafeMath for uint256;
    address public immutable converter;
    address public swapper;

    // Price oracle address, which is used for verification of swapping assets amount
    address public priceOracle;
    address public limitManager;
    address public levelManager;
    address public marketManager;
    address public cashbackManager;

    // Governor can set followings:
    address public governorAddress; // Governance address

    /*** Main Actions ***/
    // user's deposited balance.
    // user  => ( market => balances)
    mapping(address => mapping(address => uint256)) public usersBalances;

    mapping(address => uint256) public userValidTimes;

    //prevent reentrancy attack
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;
    bool private initialized;

    // uint256 public timeDiff;
    struct SignKeys {
        uint8 v;
        bytes32 r;
        bytes32 s;
    }
    struct SignData {
        bytes4 method;
        uint256 id;
        address market;
        address userAddr;
        uint256 amount;
        uint256 validTime;
    }
    // emit event

    event UserBalanceChanged(
        address indexed userAddr,
        address indexed market,
        uint256 amount
    );

    event GovernorAddressChanged(
        address indexed previousGovernor,
        address indexed newGovernor
    );
    event MonthlyFeePaid(
        uint256 id,
        address userAddr,
        uint256 userValidTime,
        uint256 usdAmount
    );
    event UserDeposit(address userAddr, address market, uint256 amount);
    event UserWithdraw(
        uint256 id,
        address userAddr,
        address market,
        uint256 amount,
        uint256 remainedBalance
    );
    event SignerBuyGoods(
        uint256 id,
        address signer1,
        address signer2,
        address market,
        address userAddr,
        uint256 usdAmount
    );
    event UserMainMarketChanged(
        uint256 id,
        address userAddr,
        address market,
        address beforeMarket
    );
    event ContractAddressChanged(
        address priceOracle,
        address swapper,
        address limitManager,
        address levelManager,
        address marketManager,
        address cashbackManager
    );
    event WithdrawTokens(address token, address to, uint256 amount);

    // verified
    /**
     * Contract initialization.
     *
     * The `constructor` is executed only once when the contract is created.
     * The `public` modifier makes a function callable from outside the contract.
     */
    constructor(address _converter, address _initialSigner)
        SignerRole(_initialSigner)
    {
        converter = _converter;
        // The totalSupply is assigned to transaction sender, which is the account
        // that is deploying the contract.
    }

    // verified
    receive() external payable {
        // require(msg.sender == WETH, 'Not WETH9');
    }

    // verified
    function initialize(
        address _priceOracle,
        address _limitManager,
        address _levelManager,
        address _marketManager,
        address _cashbackManager,
        address _financialAddress,
        address _masterAddress,
        address _treasuryAddress,
        address _governorAddress,
        address _monthlyFeeAddress,
        address _stakeContractAddress,
        address _swapper
    ) public {
        require(!initialized, "ai");
        // owner = _owner;
        // _addSigner(_owner);
        priceOracle = _priceOracle;
        limitManager = _limitManager;
        levelManager = _levelManager;
        marketManager = _marketManager;
        cashbackManager = _cashbackManager;
        treasuryAddress = _treasuryAddress;
        financialAddress = _financialAddress;
        masterAddress = _masterAddress;
        governorAddress = _governorAddress;
        monthlyFeeAddress = _monthlyFeeAddress;
        stakeContractAddress = _stakeContractAddress;
        swapper = _swapper;
        //private variables initialize.
        _status = _NOT_ENTERED;
        //initialize OwnerConstants arrays

        stakePercent = 15 * (100 + 15);
        buyFeePercent = 250;
        buyTxFee = 0.7 ether;
        withdrawFeePercent = 0;
        monthlyFeeAmount = 6.99 ether;
        okseMonthlyProfit = 1000;
        initialized = true;
    }

    /// modifier functions
    // verified
    modifier onlyGovernor() {
        require(_msgSender() == governorAddress, "og");
        _;
    }
    // // verified
    modifier marketEnabled(address market) {
        require(IMarketManager(marketManager).marketEnable(market), "mdnd");
        _;
    }
    // verified
    modifier noExpired(address userAddr) {
        require(!getUserExpired(userAddr), "user expired");
        _;
    }

    /**
     * @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.
     */
    // verified
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "rc");

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

        _;

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

    modifier validSignOfUser(
        SignData calldata sign_data,
        SignKeys calldata sign_key
    ) {
        require(
            sign_data.userAddr == getecrecover(sign_data, sign_key),
            "ssst"
        );
        _;
    }
    modifier noEmergency() {
        require(!IMarketManager(marketManager).emergencyStop(), "stopped");
        _;
    }

    function getUserOkseBalance(address userAddr)
        external
        view
        returns (uint256)
    {
        return usersBalances[userAddr][IMarketManager(marketManager).OKSE()];
    }

    // verified
    function getUserExpired(address _userAddr) public view returns (bool) {
        if (userValidTimes[_userAddr].add(25 days) > block.timestamp) {
            return false;
        }
        return true;
    }

    // set Governance address
    function setGovernor(address newGovernor) public onlyGovernor {
        address oldGovernor = governorAddress;
        governorAddress = newGovernor;
        emit GovernorAddressChanged(oldGovernor, newGovernor);
    }

    // verified
    function updateSigner(address _signer, bool bAddOrRemove)
        public
        onlyGovernor
    {
        if (bAddOrRemove) {
            _addSigner(_signer);
        } else {
            _removeSigner(_signer);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    function onUpdateUserBalance(
        address userAddr,
        address market,
        uint256 amount,
        uint256 beforeAmount
    ) internal returns (bool) {
        emit UserBalanceChanged(userAddr, market, amount);
        if (market != IMarketManager(marketManager).OKSE()) return true;
        return
            ILevelManager(levelManager).updateUserLevel(userAddr, beforeAmount);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    // newly verified
    function deposit(address market, uint256 amount)
        public
        marketEnabled(market)
        nonReentrant
        noEmergency
    {
        TransferHelper.safeTransferFrom(
            market,
            msg.sender,
            address(this),
            amount
        );
        _addUserBalance(market, msg.sender, amount);
        emit UserDeposit(msg.sender, market, amount);
    }

    // newly verified
    function depositETH() public payable nonReentrant {
        address WETH = IMarketManager(marketManager).WETH();
        require(IMarketManager(marketManager).marketEnable(WETH), "me");
        IWETH9(WETH).deposit{value: msg.value}();
        _addUserBalance(WETH, msg.sender, msg.value);
        emit UserDeposit(msg.sender, WETH, msg.value);
    }

    // verified
    function _addUserBalance(
        address market,
        address userAddr,
        uint256 amount
    ) internal marketEnabled(market) {
        uint256 beforeAmount = usersBalances[userAddr][market];
        usersBalances[userAddr][market] = usersBalances[userAddr][market].add(
            amount
        );
        onUpdateUserBalance(
            userAddr,
            market,
            usersBalances[userAddr][market],
            beforeAmount
        );
    }

    // newly verified
    function setUserMainMarket(
        uint256 id,
        address market,
        uint256 validTime,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public {
        address userAddr = msg.sender;
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        require(
            isSigner(
                ecrecover(
                    toEthSignedMessageHash(
                        keccak256(
                            abi.encodePacked(
                                this,
                                SET_USER_MAIN_MARKET,
                                id,
                                userAddr,
                                market,
                                chainId,
                                uint256(0),
                                validTime
                            )
                        )
                    ),
                    v,
                    r,
                    s
                )
            ),
            "summ"
        );
        require(signatureId[id] == false, "pru");
        signatureId[id] = true;
        require(validTime > block.timestamp, "expired");
        address beforeMarket = IMarketManager(marketManager).getUserMainMarket(
            userAddr
        );
        IMarketManager(marketManager).setUserMainMakret(userAddr, market);
        emit UserMainMarketChanged(id, userAddr, market, beforeMarket);
    }

    // verified
    function payMonthlyFee(
        uint256 id,
        SignData calldata _data,
        SignKeys calldata user_key,
        address market
    )
        public
        nonReentrant
        marketEnabled(market)
        noEmergency
        validSignOfUser(_data, user_key)
        onlySigner
    {
        address userAddr = _data.userAddr;
        require(userValidTimes[userAddr] <= block.timestamp, "e");
        require(monthlyFeeAmount <= _data.amount, "over paid");
        require(
            signatureId[id] == false && _data.method == PAY_MONTHLY_FEE,
            "pru"
        );
        signatureId[id] = true;
        // increase valid period

        // extend user's valid time
        uint256 _monthlyFee = getMonthlyFeeAmount(
            market == IMarketManager(marketManager).OKSE()
        );
        uint256 _tempVal = _monthlyFee;
        userValidTimes[userAddr] = block.timestamp.add(CARD_VALIDATION_TIME);

        if (stakeContractAddress != address(0)) {
            _tempVal = (_monthlyFee.mul(10000)).div(stakePercent.add(10000));
        }

        uint256 beforeAmount = usersBalances[userAddr][market];
        calculateAmount(
            market,
            userAddr,
            _tempVal,
            monthlyFeeAddress,
            stakeContractAddress,
            stakePercent
        );
        onUpdateUserBalance(
            userAddr,
            market,
            usersBalances[userAddr][market],
            beforeAmount
        );
        emit MonthlyFeePaid(
            id,
            userAddr,
            userValidTimes[userAddr],
            _monthlyFee
        );
    }

    // newly verified
    function withdraw(
        uint256 id,
        address market,
        uint256 amount,
        uint256 validTime,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public nonReentrant {
        address userAddr = msg.sender;
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        require(
            isSigner(
                ecrecover(
                    toEthSignedMessageHash(
                        keccak256(
                            abi.encodePacked(
                                this,
                                WITHDRAW,
                                id,
                                userAddr,
                                market,
                                chainId,
                                amount,
                                validTime
                            )
                        )
                    ),
                    v,
                    r,
                    s
                )
            ),
            "ssst"
        );
        require(signatureId[id] == false, "pru");
        signatureId[id] = true;
        require(validTime > block.timestamp, "expired");
        uint256 beforeAmount = usersBalances[userAddr][market];
        // require(beforeAmount >= amount, "ib");
        usersBalances[userAddr][market] = beforeAmount.sub(amount);
        address WETH = IMarketManager(marketManager).WETH();
        if (market == WETH) {
            IWETH9(WETH).withdraw(amount);
            if (treasuryAddress != address(0)) {
                uint256 feeAmount = (amount.mul(withdrawFeePercent)).div(10000);
                if (feeAmount > 0) {
                    TransferHelper.safeTransferETH(treasuryAddress, feeAmount);
                }
                TransferHelper.safeTransferETH(
                    msg.sender,
                    amount.sub(feeAmount)
                );
            } else {
                TransferHelper.safeTransferETH(msg.sender, amount);
            }
        } else {
            if (treasuryAddress != address(0)) {
                uint256 feeAmount = (amount.mul(withdrawFeePercent)).div(10000);
                if (feeAmount > 0) {
                    TransferHelper.safeTransfer(
                        market,
                        treasuryAddress,
                        feeAmount
                    );
                }
                TransferHelper.safeTransfer(
                    market,
                    msg.sender,
                    amount.sub(feeAmount)
                );
            } else {
                TransferHelper.safeTransfer(market, msg.sender, amount);
            }
        }
        uint256 userBal = usersBalances[userAddr][market];
        onUpdateUserBalance(userAddr, market, userBal, beforeAmount);
        emit UserWithdraw(id, userAddr, market, amount, userBal);
    }

    // decimal of usdAmount is 18
    // newly verified
    function buyGoods(SignData calldata _data, SignKeys[2] calldata signer_key)
        external
        nonReentrant
        marketEnabled(_data.market)
        noExpired(_data.userAddr)
        noEmergency
    {
        address[2] memory signers = [
            getecrecover(_data, signer_key[0]),
            getecrecover(_data, signer_key[1])
        ];
        require(
            isSigner(signers[0]) &&
                isSigner(signers[1]) &&
                (signers[0] != signers[1]),
            "is"
        );
        require(
            signatureId[_data.id] == false && _data.method == BUYGOODS,
            "pru"
        );
        signatureId[_data.id] = true;
        if (_data.market == IMarketManager(marketManager).OKSE()) {
            require(IMarketManager(marketManager).oksePaymentEnable(), "jsy");
        }
        require(
            IMarketManager(marketManager).getUserMainMarket(_data.userAddr) ==
                _data.market,
            "jsy2"
        );
        uint256 spendAmount = _makePayment(
            _data.market,
            _data.userAddr,
            _data.amount
        );
        cashBack(_data.userAddr, spendAmount);
        emit SignerBuyGoods(
            _data.id,
            signers[0],
            signers[1],
            _data.market,
            _data.userAddr,
            _data.amount
        );
    }

    // deduce user assets using usd amount
    // decimal of usdAmount is 18
    // verified
    function _makePayment(
        address market,
        address userAddr,
        uint256 usdAmount
    ) internal returns (uint256 spendAmount) {
        uint256 beforeAmount = usersBalances[userAddr][market];
        spendAmount = calculateAmount(
            market,
            userAddr,
            usdAmount,
            masterAddress,
            treasuryAddress,
            buyFeePercent
        );
        ILimitManager(limitManager).updateUserSpendAmount(userAddr, usdAmount);

        onUpdateUserBalance(
            userAddr,
            market,
            usersBalances[userAddr][market],
            beforeAmount
        );
    }

    // calculate aseet amount from market and required usd amount
    // decimal of usdAmount is 18
    // spendAmount is decimal 18
    function calculateAmount(
        address market,
        address userAddr,
        uint256 usdAmount,
        address targetAddress,
        address feeAddress,
        uint256 feePercent
    ) internal returns (uint256 spendAmount) {
        uint256 _amount;
        address USDC = IMarketManager(marketManager).USDC();
        if (feeAddress != address(0)) {
            _amount = usdAmount.add((usdAmount.mul(feePercent)).div(10000)).add(
                    buyTxFee
                );
        } else {
            _amount = usdAmount;
        }
        // change _amount to USDC asset amounts
        uint256 assetAmountIn = IConverter(converter).getAssetAmount(
            market,
            _amount,
            priceOracle
        );
        assetAmountIn = assetAmountIn.add(
            (assetAmountIn.mul(IMarketManager(marketManager).slippage())).div(10000)
        );
        _amount = IConverter(converter).convertUsdAmountToAssetAmount(
            _amount,
            USDC
        );
        uint256 userBal = usersBalances[userAddr][market];
        if (market != USDC) {
            // we need to change somehting here, because if there are not pair {market, USDC} , then we have to add another path
            // so please check the path is exist and if no, please add market, weth, usdc to path
            address[] memory path = ISwapper(swapper).getOptimumPath(
                market,
                USDC
            );
            uint256[] memory amounts = ISwapper(swapper).getAmountsIn(
                _amount,
                path
            );

            require(amounts[0] < assetAmountIn, "ua");
            usersBalances[userAddr][market] = userBal.sub(amounts[0]);
            TransferHelper.safeTransfer(
                path[0],
                ISwapper(swapper).GetReceiverAddress(path),
                amounts[0]
            );
            ISwapper(swapper)._swap(amounts, path, address(this));
        } else {
            // require(_amount <= usersBalances[userAddr][market], "uat");
            require(_amount < assetAmountIn, "au");
            usersBalances[userAddr][market] = userBal.sub(_amount);
        }
        require(targetAddress != address(0), "mis");
        uint256 usdcAmount = IConverter(converter)
            .convertUsdAmountToAssetAmount(usdAmount, USDC);
        require(_amount >= usdcAmount, "sp");
        TransferHelper.safeTransfer(USDC, targetAddress, usdcAmount);
        uint256 fee = _amount.sub(usdcAmount);
        if (feeAddress != address(0))
            TransferHelper.safeTransfer(USDC, feeAddress, fee);
        spendAmount = IConverter(converter).convertAssetAmountToUsdAmount(
            _amount,
            USDC
        );
    }

    function cashBack(address userAddr, uint256 usdAmount) internal {
        if (!ICashBackManager(cashbackManager).cashBackEnable()) return;
        uint256 cashBackPercent = ICashBackManager(cashbackManager)
            .getCashBackPercent(
                ILevelManager(levelManager).getUserLevel(userAddr)
            );
        address OKSE = IMarketManager(marketManager).OKSE();
        uint256 okseAmount = IConverter(converter).getAssetAmount(
            OKSE,
            (usdAmount.mul(cashBackPercent)).div(10000),
            priceOracle
        );
        // require(ERC20Interface(OKSE).balanceOf(address(this)) >= okseAmount , "insufficient OKSE");
        if (usersBalances[financialAddress][OKSE] > okseAmount) {
            usersBalances[financialAddress][OKSE] = usersBalances[
                financialAddress
            ][OKSE].sub(okseAmount);
            //needs extra check that owner deposited how much OKSE for cashBack
            _addUserBalance(OKSE, userAddr, okseAmount);
        }
    }

    // verified
    function getUserAssetAmount(address userAddr, address market)
        public
        view
        returns (uint256)
    {
        return usersBalances[userAddr][market];
    }

    // verified
    function encodePackedData(SignData calldata _data)
        public
        view
        returns (bytes32)
    {
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        return
            keccak256(
                abi.encodePacked(
                    this,
                    _data.method,
                    _data.id,
                    _data.userAddr,
                    _data.market,
                    chainId,
                    _data.amount,
                    _data.validTime
                )
            );
    }

    // verified
    function getecrecover(SignData calldata _data, SignKeys calldata key)
        public
        view
        returns (address)
    {
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        return
            ecrecover(
                toEthSignedMessageHash(
                    keccak256(
                        abi.encodePacked(
                            this,
                            _data.method,
                            _data.id,
                            _data.userAddr,
                            _data.market,
                            chainId,
                            _data.amount,
                            _data.validTime
                        )
                    )
                ),
                key.v,
                key.r,
                key.s
            );
    }

    // verified
    function setContractAddress(bytes calldata signData, bytes calldata keys)
        public
        validSignOfOwner(signData, keys, "setContractAddress")
    {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        (
            address _priceOracle,
            address _swapper,
            address _limitManager,
            address _levelManager,
            address _marketManager,
            address _cashbackManager
        ) = abi.decode(
                params,
                (address, address, address, address, address, address)
            );
        priceOracle = _priceOracle;
        swapper = _swapper;
        limitManager = _limitManager;
        levelManager = _levelManager;
        marketManager = _marketManager;
        cashbackManager = _cashbackManager;
        emit ContractAddressChanged(
            priceOracle,
            swapper,
            limitManager,
            levelManager,
            marketManager,
            cashbackManager
        );
    }

    // owner function
    function withdrawTokens(bytes calldata signData, bytes calldata keys)
        public
        validSignOfOwner(signData, keys, "withdrawTokens")
    {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        (address token, address to) = abi.decode(params, (address, address));

        require(!IMarketManager(marketManager).isMarketExist(token), "me");
        uint256 amount;
        if (token == address(0)) {
            amount = address(this).balance;
            TransferHelper.safeTransferETH(to, amount);
        } else {
            amount = ERC20Interface(token).balanceOf(address(this));
            TransferHelper.safeTransfer(token, to, amount);
        }
        emit WithdrawTokens(token, to, amount);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

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

abstract contract PriceOracle {
    /// @notice Indicator that this is a PriceOracle contract (for inspection)
    bool public constant isPriceOracle = true;

    /**
      * @notice Get the underlying price of a cToken asset
      * @param market The cToken to get the underlying price of
      * @return The underlying asset price mantissa (scaled by 1e18).
      *  Zero means the price is unavailable.
      */
    function getUnderlyingPrice(address market) external virtual view returns (uint);

}

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface ILimitManager {
    function getUserLimit(address userAddr) external view returns (uint256);

    function getDailyLimit(uint256 level) external view returns (uint256);

    function getSpendAmountToday(address userAddr)
        external
        view
        returns (uint256);

    function withinLimits(address userAddr, uint256 usdAmount)
        external
        view
        returns (bool);

    function updateUserSpendAmount(address userAddr, uint256 usdAmount)
        external;
}

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface ILevelManager {
    function getUserLevel(address userAddr) external view returns (uint256);

    function getLevel(uint256 _okseAmount) external view returns (uint256);

    function updateUserLevel(
        address userAddr,
        uint256 beforeAmount
    ) external returns (bool);
}

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface IMarketManager {
    function WETH() external view returns (address);

    function USDC() external view returns (address);

    function OKSE() external view returns (address);

    function defaultMarket() external view returns (address);

    function oksePaymentEnable() external view returns (bool);

    function emergencyStop() external view returns (bool);

    function marketEnable(address market) external view returns (bool);

    function isMarketExist(address market) external view returns (bool);

    function userMainMarket(address userAddr) external view returns (address);

    function slippage() external view returns (uint256);

    function getUserMainMarket(address userAddr)
        external
        view
        returns (address);

    function setUserMainMakret(address userAddr, address market) external;
}

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface ICashBackManager {
    function cashBackEnable() external view returns (bool);

    function getCashBackPercent(uint256 level) external view returns (uint256);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.7.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

/// @title Interface for WETH9
interface IWETH9 is IERC20 {
    /// @notice Deposit ether to get wrapped ether
    function deposit() external payable;

    /// @notice Withdraw wrapped ether to get ether
    function withdraw(uint256) external;
}

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface ISwapper {
  function _swap(
    uint256[] memory amounts,
    address[] memory path,
    address _to
  ) external;

  function getAmountsIn(
    uint256 amountOut,
    address[] memory path
  ) external view returns (uint256[] memory amounts);

  function GetReceiverAddress(
    address[] memory path
  ) external view returns (address);
  
  function getOptimumPath(
    address token0,
    address token1
  ) external view returns (address[] memory);
}

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

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

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory);

  /**
  * @dev Returns the token name.
  */
  function name() external view returns (string memory);

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

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

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

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

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

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

  /**
   * @dev Emitted when `value` tokens are moved from one account (`from`) to
   * another (`to`).
   *
   * Note that `value` may be zero.
   */
  event Transfer(address indexed from, address indexed to, uint256 value);

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

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;

interface IConverter {
    function convertUsdAmountToAssetAmount(
        uint256 usdAmount,
        address assetAddress
    ) external view returns (uint256);

    function convertAssetAmountToUsdAmount(
        uint256 assetAmount,
        address assetAddress
    ) external view returns (uint256);

    function getUsdAmount(
        address market,
        uint256 assetAmount,
        address priceOracle
    ) external view returns (uint256 usdAmount);

    function getAssetAmount(
        address market,
        uint256 usdAmount,
        address priceOracle
    ) external view returns (uint256 assetAmount);
}

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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
  /**
   * @dev Returns the addition of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `+` operator.
   *
   * Requirements:
   * - Addition cannot overflow.
   */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    return add(a, b, "SafeMath: addition overflow");
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, errorMessage);

    return c;
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, "SafeMath: subtraction overflow");
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }

  /**
   * @dev Returns the multiplication of two unsigned integers, reverting on
   * overflow.
   *
   * Counterpart to Solidity's `*` operator.
   *
   * Requirements:
   * - Multiplication cannot overflow.
   */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator. Note: this function uses a
   * `revert` opcode (which leaves remaining gas untouched) while Solidity
   * uses an invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, "SafeMath: division by zero");
  }

  /**
   * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
   * division by zero. The result is rounded towards zero.
   *
   * Counterpart to Solidity's `/` operator. Note: this function uses a
   * `revert` opcode (which leaves remaining gas untouched) while Solidity
   * uses an invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, errorMessage);
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts when dividing by zero.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, "SafeMath: modulo by zero");
  }

  /**
   * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
   * Reverts with custom message when dividing by zero.
   *
   * Counterpart to Solidity's `%` operator. This function uses a `revert`
   * opcode (which leaves remaining gas untouched) while Solidity uses an
   * invalid opcode to revert (consuming all remaining gas).
   *
   * Requirements:
   * - The divisor cannot be zero.
   */
  function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

//SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;
import "./MultiSigOwner.sol";
import "./libraries/SafeMath.sol";

contract OwnerConstants is MultiSigOwner {
    using SafeMath for uint256;
    // daily limit contants
    uint256 public constant MAX_LEVEL = 5;

    // this is reward address for user's withdraw and payment for goods.
    address public treasuryAddress;
    // this address should be deposit okse in his balance and users can get cashback from this address.
    address public financialAddress;
    // master address is used to send USDC tokens when user buy goods.
    address public masterAddress;
    // monthly fee rewarded address
    address public monthlyFeeAddress;

    // staking contract address, which is used to receive 20% of monthly fee, so staked users can be rewarded from this contract
    address public stakeContractAddress;
    // statking amount of monthly fee
    uint256 public stakePercent; // 15 %

    // withdraw fee and payment fee should not exeed this amount, 1% is coresponding to 100.
    uint256 public constant MAX_FEE_AMOUNT = 500; // 5%
    // buy fee setting.
    uint256 public buyFeePercent; // 1%

    // withdraw fee setting.
    uint256 public withdrawFeePercent; // 0.1 %

    // set monthly fee of user to use card payment, unit is usd amount ( 1e18)
    uint256 public monthlyFeeAmount; // 6.99 USD
    // if user pay monthly fee using okse, then he will pay less amount fro this percent. 0% => 0, 100% => 10000
    uint256 public okseMonthlyProfit; // 10%
    // buy tx fee in usd
    uint256 public buyTxFee; // 0.7 usd
    event ManagerAddressChanged(
        address treasuryAddress,
        address financialAddress,
        address masterAddress,
        address monthlyFeeAddress
    );
    event FeeValuesChanged(
        uint256 monthlyFeeAmount,
        uint256 okseMonthlyProfit,
        uint256 withdrawFeePercent,
        uint256 buyTxFee,
        uint256 buyFeePercent
    );
    event StakeContractParamChanged(
        address stakeContractAddress,
        uint256 stakePercent
    );

    constructor() {}

    function getMonthlyFeeAmount(bool payFromOkse)
        public
        view
        returns (uint256)
    {
        uint256 result;
        if (payFromOkse) {
            result = monthlyFeeAmount.sub(
                (monthlyFeeAmount.mul(okseMonthlyProfit)).div(10000)
            );
        } else {
            result = monthlyFeeAmount;
        }
        return result;
    }

    function setManagerAddresses(bytes calldata signData, bytes calldata keys)
        public
        validSignOfOwner(signData, keys, "setManagerAddresses")
    {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        (
            address _newTreasuryAddress,
            address _newFinancialAddress,
            address _newMasterAddress,
            address _mothlyFeeAddress
        ) = abi.decode(params, (address, address, address, address));

        treasuryAddress = _newTreasuryAddress;
        financialAddress = _newFinancialAddress;
        masterAddress = _newMasterAddress;
        monthlyFeeAddress = _mothlyFeeAddress;
        emit ManagerAddressChanged(
            treasuryAddress,
            financialAddress,
            masterAddress,
            monthlyFeeAddress
        );
    }

    // verified
    function setFeeValues(bytes calldata signData, bytes calldata keys)
        public
        validSignOfOwner(signData, keys, "setFeeValues")
    {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        (
            uint256 _monthlyFeeAmount,
            uint256 _okseMonthlyProfit,
            uint256 _withdrawFeePercent,
            uint256 newBuyFeePercent,
            uint256 newBuyTxFee
        ) = abi.decode(params, (uint256, uint256, uint256, uint256, uint256));
        require(_okseMonthlyProfit <= 10000, "over percent");
        require(_withdrawFeePercent <= MAX_FEE_AMOUNT, "mfo");
        monthlyFeeAmount = _monthlyFeeAmount;
        okseMonthlyProfit = _okseMonthlyProfit;
        withdrawFeePercent = _withdrawFeePercent;
        require(newBuyFeePercent <= MAX_FEE_AMOUNT, "mpo");
        buyFeePercent = newBuyFeePercent;
        buyTxFee = newBuyTxFee;
        emit FeeValuesChanged(
            monthlyFeeAmount,
            okseMonthlyProfit,
            withdrawFeePercent,
            buyTxFee,
            buyFeePercent
        );
    }

    function setStakeContractParams(
        bytes calldata signData,
        bytes calldata keys
    ) public validSignOfOwner(signData, keys, "setStakeContractParams") {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        (address _stakeContractAddress, uint256 _stakePercent) = abi.decode(
            params,
            (address, uint256)
        );
        stakeContractAddress = _stakeContractAddress;
        stakePercent = _stakePercent;
        emit StakeContractParamChanged(stakeContractAddress, stakePercent);
    }
}

//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.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];
  }
}

/*
 * @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 GSN 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 {
  // Empty internal constructor, to prevent people from mistakenly deploying
  // an instance of this contract, which should be used via inheritance.
  constructor() {}

  // solhint-disable-previous-line no-empty-blocks

  function _msgSender() internal view returns (address payable) {
    return msg.sender;
  }

  function _msgData() internal view returns (bytes memory) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
  }
}

abstract contract SignerRole is Context {
  using Roles for Roles.Role;

  event SignerAdded(address indexed account);
  event SignerRemoved(address indexed account);

  Roles.Role private _signers;

  constructor(address _signer) {
    _addSigner(_signer);
  }

  modifier onlySigner() {
    require(
      isSigner(_msgSender()),
      "SignerRole: caller does not have the Signer role"
    );
    _;
  }

  function isSigner(address account) public view returns (bool) {
    return _signers.has(account);
  }

  function _addSigner(address account) internal {
    _signers.add(account);
    emit SignerAdded(account);
  }

  function _removeSigner(address account) internal {
    _signers.remove(account);
    emit SignerRemoved(account);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

// SPDX-License-Identifier: LICENSED
pragma solidity ^0.7.0;
pragma abicoder v2;

// 2/3 Multi Sig Owner
contract MultiSigOwner {
    address[] public owners;
    mapping(uint256 => bool) public signatureId;
    bool private initialized;
    // events
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );
    event SignValidTimeChanged(uint256 newValue);
    modifier validSignOfOwner(
        bytes calldata signData,
        bytes calldata keys,
        string memory functionName
    ) {
        require(isOwner(msg.sender), "on");
        address signer = getSigner(signData, keys);
        require(
            signer != msg.sender && isOwner(signer) && signer != address(0),
            "is"
        );
        (bytes4 method, uint256 id, uint256 validTime, ) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        require(
            signatureId[id] == false &&
                method == bytes4(keccak256(bytes(functionName))),
            "sru"
        );
        require(validTime > block.timestamp, "ep");
        signatureId[id] = true;
        _;
    }

    function isOwner(address addr) public view returns (bool) {
        bool _isOwner = false;
        for (uint256 i = 0; i < owners.length; i++) {
            if (owners[i] == addr) {
                _isOwner = true;
            }
        }
        return _isOwner;
    }

    constructor() {}

    function initializeOwners(address[3] memory _owners) public {
        require(
            !initialized &&
                _owners[0] != address(0) &&
                _owners[1] != address(0) &&
                _owners[2] != address(0),
            "ai"
        );
        owners = [_owners[0], _owners[1], _owners[2]];
        initialized = true;
    }

    function getSigner(bytes calldata _data, bytes calldata keys)
        public
        view
        returns (address)
    {
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        (uint8 v, bytes32 r, bytes32 s) = abi.decode(
            keys,
            (uint8, bytes32, bytes32)
        );
        return
            ecrecover(
                toEthSignedMessageHash(
                    keccak256(abi.encodePacked(this, chainId, _data))
                ),
                v,
                r,
                s
            );
    }

    function encodePackedData(bytes calldata _data)
        public
        view
        returns (bytes32)
    {
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        return keccak256(abi.encodePacked(this, chainId, _data));
    }

    function toEthSignedMessageHash(bytes32 hash)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
            );
    }

    // Set functions
    // verified
    function transferOwnership(bytes calldata signData, bytes calldata keys)
        public
        validSignOfOwner(signData, keys, "transferOwnership")
    {
        (, , , bytes memory params) = abi.decode(
            signData,
            (bytes4, uint256, uint256, bytes)
        );
        address newOwner = abi.decode(params, (address));
        uint256 index;
        for (uint256 i = 0; i < owners.length; i++) {
            if (owners[i] == msg.sender) {
                index = i;
            }
        }
        address oldOwner = owners[index];
        owners[index] = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_converter","type":"address"},{"internalType":"address","name":"_initialSigner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"priceOracle","type":"address"},{"indexed":false,"internalType":"address","name":"swapper","type":"address"},{"indexed":false,"internalType":"address","name":"limitManager","type":"address"},{"indexed":false,"internalType":"address","name":"levelManager","type":"address"},{"indexed":false,"internalType":"address","name":"marketManager","type":"address"},{"indexed":false,"internalType":"address","name":"cashbackManager","type":"address"}],"name":"ContractAddressChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"monthlyFeeAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"okseMonthlyProfit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawFeePercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"buyTxFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"buyFeePercent","type":"uint256"}],"name":"FeeValuesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousGovernor","type":"address"},{"indexed":true,"internalType":"address","name":"newGovernor","type":"address"}],"name":"GovernorAddressChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasuryAddress","type":"address"},{"indexed":false,"internalType":"address","name":"financialAddress","type":"address"},{"indexed":false,"internalType":"address","name":"masterAddress","type":"address"},{"indexed":false,"internalType":"address","name":"monthlyFeeAddress","type":"address"}],"name":"ManagerAddressChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"userValidTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"usdAmount","type":"uint256"}],"name":"MonthlyFeePaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"SignValidTimeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"address","name":"signer1","type":"address"},{"indexed":false,"internalType":"address","name":"signer2","type":"address"},{"indexed":false,"internalType":"address","name":"market","type":"address"},{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"usdAmount","type":"uint256"}],"name":"SignerBuyGoods","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"stakeContractAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"stakePercent","type":"uint256"}],"name":"StakeContractParamChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddr","type":"address"},{"indexed":true,"internalType":"address","name":"market","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UserBalanceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"address","name":"market","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UserDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"address","name":"market","type":"address"},{"indexed":false,"internalType":"address","name":"beforeMarket","type":"address"}],"name":"UserMainMarketChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"address","name":"market","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"remainedBalance","type":"uint256"}],"name":"UserWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawTokens","type":"event"},{"inputs":[],"name":"BUYGOODS","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CARD_VALIDATION_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_LEVEL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAY_MONTHLY_FEE","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SET_USER_MAIN_MARKET","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAW","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyFeePercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes4","name":"method","type":"bytes4"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"validTime","type":"uint256"}],"internalType":"struct OkseCard.SignData","name":"_data","type":"tuple"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct OkseCard.SignKeys[2]","name":"signer_key","type":"tuple[2]"}],"name":"buyGoods","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyTxFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cashbackManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"converter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"market","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"encodePackedData","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes4","name":"method","type":"bytes4"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"validTime","type":"uint256"}],"internalType":"struct OkseCard.SignData","name":"_data","type":"tuple"}],"name":"encodePackedData","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"financialAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"payFromOkse","type":"bool"}],"name":"getMonthlyFeeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_data","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"getSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"address","name":"market","type":"address"}],"name":"getUserAssetAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddr","type":"address"}],"name":"getUserExpired","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddr","type":"address"}],"name":"getUserOkseBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes4","name":"method","type":"bytes4"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"validTime","type":"uint256"}],"internalType":"struct OkseCard.SignData","name":"_data","type":"tuple"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct OkseCard.SignKeys","name":"key","type":"tuple"}],"name":"getecrecover","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governorAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_priceOracle","type":"address"},{"internalType":"address","name":"_limitManager","type":"address"},{"internalType":"address","name":"_levelManager","type":"address"},{"internalType":"address","name":"_marketManager","type":"address"},{"internalType":"address","name":"_cashbackManager","type":"address"},{"internalType":"address","name":"_financialAddress","type":"address"},{"internalType":"address","name":"_masterAddress","type":"address"},{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"address","name":"_governorAddress","type":"address"},{"internalType":"address","name":"_monthlyFeeAddress","type":"address"},{"internalType":"address","name":"_stakeContractAddress","type":"address"},{"internalType":"address","name":"_swapper","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[3]","name":"_owners","type":"address[3]"}],"name":"initializeOwners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"levelManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"monthlyFeeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"monthlyFeeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"okseMonthlyProfit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"owners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"components":[{"internalType":"bytes4","name":"method","type":"bytes4"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"validTime","type":"uint256"}],"internalType":"struct OkseCard.SignData","name":"_data","type":"tuple"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct OkseCard.SignKeys","name":"user_key","type":"tuple"},{"internalType":"address","name":"market","type":"address"}],"name":"payMonthlyFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"priceOracle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"setContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"setFeeValues","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newGovernor","type":"address"}],"name":"setGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"setManagerAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"setStakeContractParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"uint256","name":"validTime","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"setUserMainMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"signatureId","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakePercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"bool","name":"bAddOrRemove","type":"bool"}],"name":"updateSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userValidTimes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"usersBalances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"market","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"validTime","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFeePercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signData","type":"bytes"},{"internalType":"bytes","name":"keys","type":"bytes"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000515695578eecd92d7747897df7756967912e678a0000000000000000000000005126ea3894671e1c6cce47d3fb462e3c270e499e

-----Decoded View---------------
Arg [0] : _converter (address): 0x515695578eecd92d7747897df7756967912e678a
Arg [1] : _initialSigner (address): 0x5126ea3894671e1c6cce47d3fb462e3c270e499e

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000515695578eecd92d7747897df7756967912e678a
Arg [1] : 0000000000000000000000005126ea3894671e1c6cce47d3fb462e3c270e499e