Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•  contract ERC20 is IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•  contract Ownable
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Address
•    - function isContract(address account)
• interface IWhitelisted
•    - function isWhitelisted(address accoun ...
• interface IExchange
•    - function swap(
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
• interface ITokenTransferProxy
•    - function transferFrom(
•    - function freeGSTTokens(uint256 tokens ...
• library Utils
•    - function ethAddress()
•    - function maxUint()
•    - function approve(
•    - function transferTokens(
•    - function tokenBalance(
•    - function refundGas(address tokenProxy ...
•    - function freeGasTokens(address tokenP ...
• interface IGST2
•    - function freeUpTo(uint256 value)
•    - function freeFromUpTo(address from, u ...
•    - function balanceOf(address who)
•    - function mint(uint256 value)
•  contract TokenTransferProxy is Own ...
•    - function getGSTHolder()
•    - function getGST()
•    - function changeGSTTokenHolder(address ...
•    - function transferFrom(
•    - function freeGSTTokens(uint256 tokens ...
• interface IPartnerRegistry
•    - function getPartnerContract(string ca ...
•    - function addPartner(
•    - function removePartner(string calldat ...
• interface IPartner
•    - function getReferralId()
•    - function getFeeWallet()
•    - function getFee()
•    - function getPartnerShare()
•    - function getParaswapShare()
•    - function changeFeeWallet(address paya ...
•    - function changeFee(uint256 newFee)
•  contract AugustusSwapper is Ownabl ... *
•    - function()
•    - function getPartnerRegistry()
•    - function getWhitelistAddress()
•    - function getFeeWallet()
•    - function setFeeWallet(address payable ...
•    - function setPartnerRegistry(address p ...
•    - function setWhitelistAddress(address ...
•    - function getTokenTransferProxy()
•    - function changeGSTHolder(address gstH ...
•    - function paused()
•    - function pause()
•    - function unpause()
•    - function ownerTransferTokens(
•    - function multiSwap(
•    - function takeFeeAndTransferTokens(
•    - function performSwap(
•    - function _takeFee(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-05-23
*/

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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-solidity/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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see `ERC20Detailed`.
 */
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.
     *
     * > 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);
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

pragma solidity ^0.5.0;



/**
 * @dev Implementation of the `IERC20` interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using `_mint`.
 * For a generic mechanism see `ERC20Mintable`.
 *
 * *For a detailed writeup see our guide [How to implement supply
 * mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an `Approval` event is emitted on calls to `transferFrom`.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard `decreaseAllowance` and `increaseAllowance`
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See `IERC20.approve`.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    /**
     * @dev See `IERC20.totalSupply`.
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See `IERC20.balanceOf`.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See `IERC20.transfer`.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    /**
     * @dev See `IERC20.allowance`.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See `IERC20.approve`.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev See `IERC20.transferFrom`.
     *
     * Emits an `Approval` event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of `ERC20`;
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `value`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to `approve` that can be used as a mitigation for
     * problems described in `IERC20.approve`.
     *
     * Emits an `Approval` event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to `approve` that can be used as a mitigation for
     * problems described in `IERC20.approve`.
     *
     * Emits an `Approval` event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to `transfer`, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a `Transfer` event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a `Transfer` event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

     /**
     * @dev Destoys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a `Transfer` event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an `Approval` event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    /**
     * @dev Destoys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See `_burn` and `_approve`.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
    }
}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.0;

/**
 * @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.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be aplied to your functions to restrict their use to
 * the owner.
 */
contract Ownable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _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 onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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 onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: openzeppelin-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.0;

/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

// File: original_contracts/IWhitelisted.sol

pragma solidity 0.5.11;


interface IWhitelisted {

    function isWhitelisted(address account) external view returns (bool);
}

// File: original_contracts/lib/IExchange.sol

pragma solidity 0.5.11;



/**
* @dev This interface should be implemented by all exchanges which needs to integrate with the paraswap protocol
*/
interface IExchange {

    /**
   * @dev The function which performs the swap on an exchange.
   * Exchange needs to implement this method in order to support swapping of tokens through it
   * @param fromToken Address of the source token
   * @param toToken Address of the destination token
   * @param fromAmount Amount of source tokens to be swapped
   * @param toAmount Minimum destination token amount expected out of this swap
   * @param exchange Internal exchange or factory contract address for the exchange. For example Registry address for the Uniswap
   * @param payload Any exchange specific data which is required can be passed in this argument in encoded format which
   * will be decoded by the exchange. Each exchange will publish it's own decoding/encoding mechanism
   */
    function swap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        address exchange,
        bytes calldata payload) external payable returns (uint256);
}

// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: original_contracts/ITokenTransferProxy.sol

pragma solidity 0.5.11;


interface ITokenTransferProxy {

    function transferFrom(
        address token,
        address from,
        address to,
        uint256 amount
    )
        external;

    function freeGSTTokens(uint256 tokensToFree) external;
}

// File: original_contracts/lib/Utils.sol

pragma solidity 0.5.11;







library Utils {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address constant ETH_ADDRESS = address(
        0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
    );

    uint256 constant MAX_UINT = 2 ** 256 - 1;

    struct Route {
        address payable exchange;
        address targetExchange;
        uint percent;
        bytes payload;
        uint256 networkFee;
    }

    struct Path {
        address to;
        Route[] routes;
    }

    function ethAddress() internal pure returns (address) {return ETH_ADDRESS;}

    function maxUint() internal pure returns (uint256) {return MAX_UINT;}

    function approve(
        address addressToApprove,
        address token
    ) internal {
        if (token != ETH_ADDRESS) {
            IERC20 _token = IERC20(token);

            uint allowance = _token.allowance(address(this), addressToApprove);

            if (allowance < MAX_UINT / 10) {
                _token.safeApprove(addressToApprove, MAX_UINT);
            }
        }
    }

    function transferTokens(
        address token,
        address payable destination,
        uint256 amount
    )
    internal
    {
        if (token == ETH_ADDRESS) {
            destination.transfer(amount);
        }
        else {
            IERC20(token).safeTransfer(destination, amount);
        }
    }

    function tokenBalance(
        address token,
        address account
    )
    internal
    view
    returns (uint256)
    {
        if (token == ETH_ADDRESS) {
            return account.balance;
        } else {
            return IERC20(token).balanceOf(account);
        }
    }

    /**
    * @dev Helper method to refund gas using gas tokens
    */
    function refundGas(address tokenProxy, uint256 initialGas, uint256 mintPrice) internal {

        uint256 mintBase = 32254;
        uint256 mintToken = 36543;
        uint256 freeBase = 14154;
        uint256 freeToken = 6870;
        uint256 reimburse = 24000;

        uint256 tokens = initialGas.sub(
            gasleft()).add(freeBase).div(reimburse.mul(2).sub(freeToken)
        );

        uint256 mintCost = mintBase.add(tokens.mul(mintToken));
        uint256 freeCost = freeBase.add(tokens.mul(freeToken));
        uint256 maxreimburse = tokens.mul(reimburse);

        uint256 efficiency = maxreimburse.mul(tx.gasprice).mul(100).div(
            mintCost.mul(mintPrice).add(freeCost.mul(tx.gasprice))
        );

        if (efficiency > 100) {
            freeGasTokens(tokenProxy, tokens);
        }
    }
    
    /**
    * @dev Helper method to free gas tokens
    */
    function freeGasTokens(address tokenProxy, uint256 tokens) internal {

        uint256 tokensToFree = tokens;
        uint256 safeNumTokens = 0;
        uint256 gas = gasleft();

        if (gas >= 27710) {
            safeNumTokens = gas.sub(27710).div(1148 + 5722 + 150);
        }

        if (tokensToFree > safeNumTokens) {
            tokensToFree = safeNumTokens;
        }

        ITokenTransferProxy(tokenProxy).freeGSTTokens(tokensToFree);

    }
}

// File: original_contracts/IGST2.sol

pragma solidity 0.5.11;

interface IGST2 {

    function freeUpTo(uint256 value) external returns (uint256 freed);

    function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);

    function balanceOf(address who) external view returns (uint256);

    function mint(uint256 value) external;
}

// File: original_contracts/TokenTransferProxy.sol

pragma solidity 0.5.11;






/**
* @dev Allows owner of the contract to transfer tokens on behalf of user.
* User will need to approve this contract to spend tokens on his/her behalf
* on Paraswap platform
*/
contract TokenTransferProxy is Ownable {
    using SafeERC20 for IERC20;

    IGST2 private _gst2;

    address private _gstHolder;

    constructor(address gst2, address gstHolder) public {
        _gst2 = IGST2(gst2);
        _gstHolder = gstHolder;
    }

    function getGSTHolder() external view returns(address) {
        return _gstHolder;
    }

    function getGST() external view returns(address) {
        return address(_gst2);
    }

    function changeGSTTokenHolder(address gstHolder) external onlyOwner {
        _gstHolder = gstHolder;

    }

    /**
    * @dev Allows owner of the contract to transfer tokens on user's behalf
    * @dev Swapper contract will be the owner of this contract
    * @param token Address of the token
    * @param from Address from which tokens will be transferred
    * @param to Receipent address of the tokens
    * @param amount Amount of tokens to transfer
    */
    function transferFrom(
        address token,
        address from,
        address to,
        uint256 amount
    )
        external
        onlyOwner
    {
        IERC20(token).safeTransferFrom(from, to, amount);
    }

    function freeGSTTokens(uint256 tokensToFree) external onlyOwner {
        _gst2.freeFromUpTo(_gstHolder, tokensToFree);
    }

}

// File: original_contracts/IPartnerRegistry.sol

pragma solidity 0.5.11;


interface IPartnerRegistry {

    function getPartnerContract(string calldata referralId) external view returns(address);

    function addPartner(
        string calldata referralId,
        address feeWallet,
        uint256 fee,
        uint256 paraswapShare,
        uint256 partnerShare,
        address owner
    )
        external;

    function removePartner(string calldata referralId) external;
}

// File: original_contracts/IPartner.sol

pragma solidity 0.5.11;


interface IPartner {

    function getReferralId() external view returns(string memory);

    function getFeeWallet() external view returns(address payable);

    function getFee() external view returns(uint256);

    function getPartnerShare() external returns(uint256);

    function getParaswapShare() external returns(uint256);

    function changeFeeWallet(address payable feeWallet) external;

    function changeFee(uint256 newFee) external;
}

// File: original_contracts/AugustusSwapper.sol

pragma solidity 0.5.11;
pragma experimental ABIEncoderV2;












contract AugustusSwapper is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using Address for address;

    TokenTransferProxy private _tokenTransferProxy;

    bool private _paused;

    IWhitelisted private _whitelisted;

    IPartnerRegistry private _partnerRegistry;
    address payable private _feeWallet;

    event Paused();
    event Unpaused();

    event Swapped(
        address initiator,
        address indexed beneficiary,
        address indexed srcToken,
        address indexed destToken,
        uint256 srcAmount,
        uint256 receivedAmount,
        uint256 expectedAmount,
        string referrer
    );

    event Donation(address indexed receiver, uint256 donationPercentage);

    event FeeTaken(
        uint256 fee,
        uint256 partnerShare,
        uint256 paraswapShare
    );

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    constructor(
        address whitelist,
        address gasToken,
        address partnerRegistry,
        address payable feeWallet,
        address gstHolder
    )
        public
    {

        _partnerRegistry = IPartnerRegistry(partnerRegistry);
        _tokenTransferProxy = new TokenTransferProxy(gasToken, gstHolder);
        _whitelisted = IWhitelisted(whitelist);
        _feeWallet = feeWallet;
    }

    /**
    * @dev Fallback method to allow exchanges to transfer back ethers for a particular swap
    * It will only allow contracts to send funds to it
    */
    function() external payable whenNotPaused {
        address account = msg.sender;
        require(
            account.isContract(),
            "Sender is not a contract"
        );
    }
    
    function getPartnerRegistry() external view returns(address) {
        return address(_partnerRegistry);
    }

    function getWhitelistAddress() external view returns(address) {
        return address(_whitelisted);
    }

    function getFeeWallet() external view returns(address) {
        return _feeWallet;
    }

    function setFeeWallet(address payable feeWallet) external onlyOwner {
        require(feeWallet != address(0), "Invalid address");
        _feeWallet = feeWallet;
    }

    function setPartnerRegistry(address partnerRegistry) external onlyOwner {
        require(partnerRegistry != address(0), "Invalid address");
        _partnerRegistry = IPartnerRegistry(partnerRegistry);
    }

    function setWhitelistAddress(address whitelisted) external onlyOwner {
        require(whitelisted != address(0), "Invalid whitelist address");
        _whitelisted = IWhitelisted(whitelisted);
    }

    function getTokenTransferProxy() external view returns (address) {
        return address(_tokenTransferProxy);
    }

    function changeGSTHolder(address gstHolder) external onlyOwner {
        require(gstHolder != address(0), "Invalid address");
        _tokenTransferProxy.changeGSTTokenHolder(gstHolder);
    }

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

    /**
     * @dev Called by a pauser to pause, triggers stopped state.
     */
    function pause() external onlyOwner whenNotPaused {
        _paused = true;
        emit Paused();
    }

    /**
     * @dev Called by a pauser to unpause, returns to normal state.
     */
    function unpause() external onlyOwner whenPaused {
        _paused = false;
        emit Unpaused();
    }

    /**
    * @dev Allows owner of the contract to transfer tokens any tokens which are assigned to the contract
    * This method is for saftey if by any chance tokens or ETHs are assigned to the contract by mistake
    * @dev token Address of the token to be transferred
    * @dev destination Recepient of the token
    * @dev amount Amount of tokens to be transferred
    */
    function ownerTransferTokens(
        address token,
        address payable destination,
        uint256 amount
    )
    external
    onlyOwner
    {
        Utils.transferTokens(token, destination, amount);
    }

    /**
   * @dev The function which performs the multi path swap.
   * @param fromToken Address of the source token
   * @param toToken Address of the destination token
   * @param fromAmount Amount of source tokens to be swapped
   * @param toAmount Minimum destination token amount expected out of this swap
   * @param expectedAmount Expected amount of destination tokens without slippage
   * @param path Route to be taken for this swap to take place
   * @param mintPrice Price of gas at the time of minting of gas tokens, if any. In wei. 0 means gas token will not be used
   * @param beneficiary Beneficiary address
   * @param donationPercentage Percentage of returned amount to be transferred to beneficiary, if beneficiary is available. If this is passed as
   * 0 then 100% will be transferred to beneficiary. Pass 10000 for 100%
   * @param referrer referral id
   */
    function multiSwap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        uint256 expectedAmount,
        Utils.Path[] memory path,
        uint256 mintPrice,
        address payable beneficiary,
        uint256 donationPercentage,
        string memory referrer
    )
        public
        payable
        whenNotPaused
        returns (uint256)
    {
        //Referral id can never be empty
        require(bytes(referrer).length > 0, "Invalid referrer");

        require(donationPercentage <= 10000, "Invalid value");

        require(toAmount > 0, "To amount can not be 0");

        uint256 receivedAmount = performSwap(
            fromToken,
            toToken,
            fromAmount,
            toAmount,
            path,
            mintPrice
        );

        takeFeeAndTransferTokens(
            toToken,
            toAmount,
            receivedAmount,
            beneficiary,
            donationPercentage,
            referrer
        );

        //If any ether is left at this point then we transfer it back to the user
        uint256 remEthBalance = Utils.tokenBalance(
            Utils.ethAddress(),
            address(this)
        );
        if ( remEthBalance > 0) {
            msg.sender.transfer(remEthBalance);
        }

        //Contract should not have any remaining balance after entire execution
        require(
            Utils.tokenBalance(address(toToken), address(this)) == 0,
            "Destination tokens are stuck"
        );

        emit Swapped(
            msg.sender,
            beneficiary == address(0)?msg.sender:beneficiary,
            address(fromToken),
            address(toToken),
            fromAmount,
            receivedAmount,
            expectedAmount,
            referrer
        );

        return receivedAmount;
    }

    //Helper function to transfer final amount to the beneficiaries
    function takeFeeAndTransferTokens(
        IERC20 toToken,
        uint256 toAmount,
        uint256 receivedAmount,
        address payable beneficiary,
        uint256 donationPercentage,
        string memory referrer

    )
        private
    {
        uint256 remainingAmount = receivedAmount;

        //Take partner fee
        uint256 fee = _takeFee(
            toToken,
            receivedAmount,
            referrer
        );
        remainingAmount = receivedAmount.sub(fee);

        //If beneficiary is not a 0 address then it means it is a transfer transaction
        if (beneficiary == address(0)){
            Utils.transferTokens(address(toToken), msg.sender, remainingAmount);
        }
        else {
            //Extra check of < 100 is made to ensure that in case of 100% we do not send
            //un-necessary transfer call to the msg.sender. This will save some gas
            if (donationPercentage > 0 && donationPercentage < 10000){

                //Keep donation amount with the contract and send rest to the msg.sender
                uint256 donationAmount = remainingAmount.mul(donationPercentage).div(10000);

                Utils.transferTokens(
                    address(toToken),
                    msg.sender,
                    remainingAmount.sub(donationAmount)
                );

                remainingAmount = donationAmount;
            }

            //we will fire donation event if donationPercentage is > 0 even if it is 100%
            if (donationPercentage > 0) {
                emit Donation(beneficiary, donationPercentage);
            }

            Utils.transferTokens(address(toToken), beneficiary, remainingAmount);
        }

    }

    //Helper function to perform swap
    function performSwap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        Utils.Path[] memory path,
        uint256 mintPrice
    )
        private
        returns(uint256)
    {
        uint initialGas = gasleft();

        uint _fromAmount = fromAmount;

        require(path.length > 0, "Path not provided for swap");
        require(
            path[path.length - 1].to == address(toToken),
            "Last to token does not match toToken"
        );

        //if fromToken is not ETH then transfer tokens from user to this contract
        if (address(fromToken) != Utils.ethAddress()) {
            _tokenTransferProxy.transferFrom(
                address(fromToken),
                msg.sender,
                address(this),
                fromAmount
            );
        }

        //Assuming path will not be too long to reach out of gas exception
        for (uint i = 0; i < path.length; i++) {
            //_fromToken will be either fromToken of toToken of the previous path
            IERC20 _fromToken = i > 0 ? IERC20(path[i - 1].to) : IERC20(fromToken);
            IERC20 _toToken = IERC20(path[i].to);

            uint256 initialFromBalance = Utils.tokenBalance(address(_fromToken), address(this)).sub(_fromAmount);

            for (uint j = 0; j < path[i].routes.length; j++) {
                Utils.Route memory route = path[i].routes[j];

                //Calculating tokens to be passed to the relevant exchange
                //percentage should be 200 for 2%
                uint fromAmountSlice = _fromAmount.mul(route.percent).div(10000);
                uint256 value = route.networkFee;

                if (j == path[i].routes.length.sub(1)) {
                    uint256 remBal = Utils.tokenBalance(address(_fromToken), address(this));

                    fromAmountSlice = remBal;

                    if (address(_fromToken) == Utils.ethAddress()) {
                        //subtract network fee
                        fromAmountSlice = fromAmountSlice.sub(value);
                    }
                }

                //Check if exchange is supported
                require(_whitelisted.isWhitelisted(route.exchange), "Exchange not whitelisted");

                IExchange dex = IExchange(route.exchange);

                Utils.approve(route.exchange, address(_fromToken));

                uint256 initialExchangeFromBalance = Utils.tokenBalance(address(_fromToken), route.exchange);
                uint256 initialExchangeToBalance = Utils.tokenBalance(address(_toToken), route.exchange);

                //Call to the exchange
                if (address(_fromToken) == Utils.ethAddress()) {
                    value = value.add(fromAmountSlice);

                    dex.swap.value(value)(_fromToken, _toToken, fromAmountSlice, 1, route.targetExchange, route.payload);
                }
                else {
                    _fromToken.safeTransfer(route.exchange, fromAmountSlice);

                    dex.swap.value(value)(_fromToken, _toToken, fromAmountSlice, 1, route.targetExchange, route.payload);
                }

                require(
                    Utils.tokenBalance(address(_toToken), route.exchange) <= initialExchangeToBalance,
                    "Destination tokens are stuck in exchange"
                );
                require(
                    Utils.tokenBalance(address(_fromToken), route.exchange) <= initialExchangeFromBalance,
                    "Source tokens are stuck in exchange"
                );
            }

            _fromAmount = Utils.tokenBalance(address(_toToken), address(this));

            //Contract should not have any remaining balance after execution
            require(
                Utils.tokenBalance(address(_fromToken), address(this)) <= initialFromBalance,
                "From tokens are stuck"
            );
        }

        uint256 receivedAmount = Utils.tokenBalance(address(toToken), address(this));
        require(
            receivedAmount >= toAmount,
            "Received amount of tokens are less then expected"
        );

        if (mintPrice > 0) {
            Utils.refundGas(address(_tokenTransferProxy), initialGas, mintPrice);
        }
        return receivedAmount;
    }

    function _takeFee(
        IERC20 toToken,
        uint256 receivedAmount,
        string memory referrer
    )
        private
        returns(uint256)
    {
        address partnerContract = _partnerRegistry.getPartnerContract(referrer);

        //If there is no partner associated with the referral id then no fee will be taken
        if (partnerContract == address(0)) {
            return 0;
        }

        uint256 feePercent = IPartner(partnerContract).getFee();
        uint256 partnerSharePercent = IPartner(partnerContract).getPartnerShare();
        address payable partnerFeeWallet = IPartner(partnerContract).getFeeWallet();

        //Calculate total fee to be taken
        uint256 fee = receivedAmount.mul(feePercent).div(10000);
        //Calculate partner's share
        uint256 partnerShare = fee.mul(partnerSharePercent).div(10000);
        //All remaining fee is paraswap's share
        uint256 paraswapShare = fee.sub(partnerShare);

        Utils.transferTokens(address(toToken), partnerFeeWallet, partnerShare);
        Utils.transferTokens(address(toToken), _feeWallet, paraswapShare);

        emit FeeTaken(fee, partnerShare, paraswapShare);
        return fee;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getFeeWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"partnerRegistry","type":"address"}],"name":"setPartnerRegistry","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address payable","name":"feeWallet","type":"address"}],"name":"setFeeWallet","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getWhitelistAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"whitelisted","type":"address"}],"name":"setWhitelistAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getPartnerRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"fromToken","type":"address"},{"internalType":"contract IERC20","name":"toToken","type":"address"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"toAmount","type":"uint256"},{"internalType":"uint256","name":"expectedAmount","type":"uint256"},{"components":[{"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"address payable","name":"exchange","type":"address"},{"internalType":"address","name":"targetExchange","type":"address"},{"internalType":"uint256","name":"percent","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"uint256","name":"networkFee","type":"uint256"}],"internalType":"struct Utils.Route[]","name":"routes","type":"tuple[]"}],"internalType":"struct Utils.Path[]","name":"path","type":"tuple[]"},{"internalType":"uint256","name":"mintPrice","type":"uint256"},{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"donationPercentage","type":"uint256"},{"internalType":"string","name":"referrer","type":"string"}],"name":"multiSwap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getTokenTransferProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ownerTransferTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"gstHolder","type":"address"}],"name":"changeGSTHolder","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"whitelist","type":"address"},{"internalType":"address","name":"gasToken","type":"address"},{"internalType":"address","name":"partnerRegistry","type":"address"},{"internalType":"address payable","name":"feeWallet","type":"address"},{"internalType":"address","name":"gstHolder","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"initiator","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":true,"internalType":"address","name":"srcToken","type":"address"},{"indexed":true,"internalType":"address","name":"destToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"srcAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"receivedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"expectedAmount","type":"uint256"},{"indexed":false,"internalType":"string","name":"referrer","type":"string"}],"name":"Swapped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"donationPercentage","type":"uint256"}],"name":"Donation","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"partnerShare","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paraswapShare","type":"uint256"}],"name":"FeeTaken","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"}]

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