d-bis/dodo-contractV2
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

restruct contract repo

Browse Source
This commit is contained in:
mingda
2020-10-23 01:16:52 +08:00
parent 5f10f065e4
commit e8182dd1a1
53 changed files with 775 additions and 2575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
contracts/helper/BandBNBBUSDPriceOracleProxy.sol
View File

@@ -1,30 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IBandOracleAggregator {
function getReferenceData(string memory base, string memory quote)
external
view
returns (uint256);
}
contract BandBNBBUSDPriceOracleProxy {
IBandOracleAggregator public aggregator;
constructor(IBandOracleAggregator _aggregator) public {
aggregator = _aggregator;
}
function getPrice() public view returns (uint256) {
return aggregator.getReferenceData("BNB", "USD");
}
}

25
contracts/helper/ChainlinkCOMPUSDCPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for COMP-USDC(decimals=6) price convert
contract ChainlinkCOMPUSDCPriceOracleProxy {
address public chainlink = 0xdbd020CAeF83eFd542f4De03e3cF0C28A4428bd5;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() / 100;
}
}

25
contracts/helper/ChainlinkEthUSDCPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for WETH-USDC(decimals=6) price convert
contract ChainlinkETHPriceOracleProxy {
address public chainlink = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() / 100;
}
}

25
contracts/helper/ChainlinkEthUSDTPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for WETH-USDT(decimals=6) price convert
contract ChainlinkETHUSDTPriceOracleProxy {
address public chainlink = 0xEe9F2375b4bdF6387aa8265dD4FB8F16512A1d46;
function getPrice() external view returns (uint256) {
return 10**24 / IChainlink(chainlink).latestAnswer();
}
}

25
contracts/helper/ChainlinkLENDUSDCPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for LEND-USDC(decimals=6) price convert
contract ChainlinkLENDUSDCPriceOracleProxy {
address public chainlink = 0x4aB81192BB75474Cf203B56c36D6a13623270A67;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() / 100;
}
}

25
contracts/helper/ChainlinkLINKUSDPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for LINK-USDC(decimals=6) price convert
contract ChainlinkLINKUSDCPriceOracleProxy {
address public chainlink = 0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() / 100;
}
}

25
contracts/helper/ChainlinkSNXUSDPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for SNX-USDC(decimals=6) price convert
contract ChainlinkSNXUSDCPriceOracleProxy {
address public chainlink = 0xDC3EA94CD0AC27d9A86C180091e7f78C683d3699;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() / 100;
}
}

25
contracts/helper/ChainlinkWBTCUSDCPriceOracleProxy.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for WBTC(decimals=8)-USDC(decimals=6) price convert
contract ChainlinkWBTCUSDCPriceOracleProxy {
address public chainlink = 0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c;
function getPrice() external view returns (uint256) {
return IChainlink(chainlink).latestAnswer() * (10**8);
}
}

32
contracts/helper/ChainlinkYFIUSDCPriceOracleProxy.sol
View File

@@ -1,32 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {SafeMath} from "../lib/SafeMath.sol";
interface IChainlink {
function latestAnswer() external view returns (uint256);
}
// for YFI-USDC(decimals=6) price convert
contract ChainlinkYFIUSDCPriceOracleProxy {
using SafeMath for uint256;
address public yfiEth = 0x7c5d4F8345e66f68099581Db340cd65B078C41f4;
address public EthUsd = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
function getPrice() external view returns (uint256) {
uint256 yfiEthPrice = IChainlink(yfiEth).latestAnswer();
uint256 EthUsdPrice = IChainlink(EthUsd).latestAnswer();
return yfiEthPrice.mul(EthUsdPrice).div(10**20);
}
}

33
contracts/helper/CloneFactory.sol
View File

@@ -1,33 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface ICloneFactory {
function clone(address prototype) external returns (address proxy);
}
// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167
contract CloneFactory is ICloneFactory {
function clone(address prototype) external override returns (address proxy) {
bytes20 targetBytes = bytes20(prototype);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(
add(clone, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
proxy := create(0, clone, 0x37)
}
return proxy;
}
}

23
contracts/helper/ConstFeeRateModel.sol Normal file
View File

@@ -0,0 +1,23 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {IFeeRateModel} from "../intf/IFeeRateModel.sol";
contract ConstFeeRateModel is IFeeRateModel {
uint256 public _FEE_RATE_;
constructor(uint256 feeRate) public {
feeRate = _FEE_RATE_;
}
function getFeeRate(uint256) external override view returns (uint256) {
return _FEE_RATE_;
}
}

22
contracts/helper/ConstOracle.sol
View File

@@ -1,22 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
contract ConstOracle {
uint256 public tokenPrice;
constructor(uint256 _price) public {
tokenPrice = _price;
}
function getPrice() external view returns (uint256) {
return tokenPrice;
}
}

56
contracts/helper/MinimumOracle.sol
View File

@@ -1,56 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IMinimumOracle {
function getPrice() external view returns (uint256);
function setPrice(uint256 newPrice) external;
function transferOwnership(address newOwner) external;
}
contract MinimumOracle {
address public _OWNER_;
uint256 public tokenPrice;
// ============ Events ============
event OwnershipTransfer(address indexed previousOwner, address indexed newOwner);
// ============ Modifiers ============
modifier onlyOwner() {
require(msg.sender == _OWNER_, "NOT_OWNER");
_;
}
// ============ Functions ============
constructor() public {
_OWNER_ = msg.sender;
emit OwnershipTransfer(address(0), _OWNER_);
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0), "INVALID_OWNER");
emit OwnershipTransfer(_OWNER_, newOwner);
_OWNER_ = newOwner;
}
function setPrice(uint256 newPrice) external onlyOwner {
tokenPrice = newPrice;
}
function getPrice() external view returns (uint256) {
return tokenPrice;
}
}

440
contracts/helper/MultiSig.sol
View File

@@ -1,440 +0,0 @@
/**
*Submitted for verification at Bscscan.com on 2020-09-25
*/
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
contract MultiSigWalletWithTimelock {
uint256 public constant MAX_OWNER_COUNT = 50;
uint256 public lockSeconds = 86400;
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
event UnlockTimeSet(uint256 indexed transactionId, uint256 confirmationTime);
event LockSecondsChange(uint256 lockSeconds);
mapping(uint256 => Transaction) public transactions;
mapping(uint256 => mapping(address => bool)) public confirmations;
mapping(address => bool) public isOwner;
mapping(uint256 => uint256) public unlockTimes;
address[] public owners;
uint256 public required;
uint256 public transactionCount;
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
struct EmergencyCall {
bytes32 selector;
uint256 paramsBytesCount;
}
// Functions bypass the time lock process
EmergencyCall[] public emergencyCalls;
modifier onlyWallet() {
if (msg.sender != address(this)) revert("ONLY_WALLET_ERROR");
_;
}
modifier ownerDoesNotExist(address owner) {
if (isOwner[owner]) revert("OWNER_DOES_NOT_EXIST_ERROR");
_;
}
modifier ownerExists(address owner) {
if (!isOwner[owner]) revert("OWNER_EXISTS_ERROR");
_;
}
modifier transactionExists(uint256 transactionId) {
if (transactions[transactionId].destination == address(0))
revert("TRANSACTION_EXISTS_ERROR");
_;
}
modifier confirmed(uint256 transactionId, address owner) {
if (!confirmations[transactionId][owner]) revert("CONFIRMED_ERROR");
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
if (confirmations[transactionId][owner]) revert("NOT_CONFIRMED_ERROR");
_;
}
modifier notExecuted(uint256 transactionId) {
if (transactions[transactionId].executed) revert("NOT_EXECUTED_ERROR");
_;
}
modifier notNull(address _address) {
if (_address == address(0)) revert("NOT_NULL_ERROR");
_;
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
if (
ownerCount > MAX_OWNER_COUNT ||
_required > ownerCount ||
_required == 0 ||
ownerCount == 0
) revert("VALID_REQUIREMENT_ERROR");
_;
}
/** @dev Fallback function allows to deposit ether. */
fallback() external payable {
if (msg.value > 0) {
emit Deposit(msg.sender, msg.value);
}
}
receive() external payable {
if (msg.value > 0) {
emit Deposit(msg.sender, msg.value);
}
}
/** @dev Contract constructor sets initial owners and required number of confirmations.
* @param _owners List of initial owners.
* @param _required Number of required confirmations.
*/
constructor(address[] memory _owners, uint256 _required)
public
validRequirement(_owners.length, _required)
{
for (uint256 i = 0; i < _owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == address(0)) {
revert("OWNER_ERROR");
}
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
// initialzie Emergency calls
emergencyCalls.push(
EmergencyCall({
selector: keccak256(abi.encodePacked("claimOwnership()")),
paramsBytesCount: 0
})
);
emergencyCalls.push(
EmergencyCall({
selector: keccak256(abi.encodePacked("setK(uint256)")),
paramsBytesCount: 64
})
);
emergencyCalls.push(
EmergencyCall({
selector: keccak256(abi.encodePacked("setLiquidityProviderFeeRate(uint256)")),
paramsBytesCount: 64
})
);
}
function getEmergencyCallsCount() external view returns (uint256 count) {
return emergencyCalls.length;
}
/** @dev Allows to add a new owner. Transaction has to be sent by wallet.
* @param owner Address of new owner.
*/
function addOwner(address owner)
external
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
/** @dev Allows to remove an owner. Transaction has to be sent by wallet.
* @param owner Address of owner.
*/
function removeOwner(address owner) external onlyWallet ownerExists(owner) {
isOwner[owner] = false;
for (uint256 i = 0; i < owners.length - 1; i++) {
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.pop;
if (required > owners.length) {
changeRequirement(owners.length);
}
emit OwnerRemoval(owner);
}
/** @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
* @param owner Address of owner to be replaced.
* @param owner Address of new owner.
*/
function replaceOwner(address owner, address newOwner)
external
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint256 i = 0; i < owners.length; i++) {
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
/** @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
* @param _required Number of required confirmations.
*/
function changeRequirement(uint256 _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
/** @dev Changes the duration of the time lock for transactions.
* @param _lockSeconds Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
*/
function changeLockSeconds(uint256 _lockSeconds) external onlyWallet {
lockSeconds = _lockSeconds;
emit LockSecondsChange(_lockSeconds);
}
/** @dev Allows an owner to submit and confirm a transaction.
* @param destination Transaction target address.
* @param value Transaction ether value.
* @param data Transaction data payload.
* @return transactionId Returns transaction ID.
*/
function submitTransaction(
address destination,
uint256 value,
bytes calldata data
) external ownerExists(msg.sender) notNull(destination) returns (uint256 transactionId) {
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
emit Submission(transactionId);
confirmTransaction(transactionId);
}
/** @dev Allows an owner to confirm a transaction.
* @param transactionId Transaction ID.
*/
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
if (
isConfirmed(transactionId) &&
unlockTimes[transactionId] == 0 &&
!isEmergencyCall(transactionId)
) {
uint256 unlockTime = block.timestamp + lockSeconds;
unlockTimes[transactionId] = unlockTime;
emit UnlockTimeSet(transactionId, unlockTime);
}
}
function isEmergencyCall(uint256 transactionId) internal view returns (bool) {
bytes memory data = transactions[transactionId].data;
for (uint256 i = 0; i < emergencyCalls.length; i++) {
EmergencyCall memory emergencyCall = emergencyCalls[i];
if (
data.length == emergencyCall.paramsBytesCount + 4 &&
data.length >= 4 &&
emergencyCall.selector[0] == data[0] &&
emergencyCall.selector[1] == data[1] &&
emergencyCall.selector[2] == data[2] &&
emergencyCall.selector[3] == data[3]
) {
return true;
}
}
return false;
}
function addEmergencyCall(string memory funcName, uint256 _paramsBytesCount) public onlyWallet {
emergencyCalls.push(
EmergencyCall({
selector: keccak256(abi.encodePacked(funcName)),
paramsBytesCount: _paramsBytesCount
})
);
}
/** @dev Allows an owner to revoke a confirmation for a transaction.
* @param transactionId Transaction ID.
*/
function revokeConfirmation(uint256 transactionId)
external
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
/** @dev Allows anyone to execute a confirmed transaction.
* @param transactionId Transaction ID.
*/
function executeTransaction(uint256 transactionId)
external
ownerExists(msg.sender)
notExecuted(transactionId)
{
require(block.timestamp >= unlockTimes[transactionId], "TRANSACTION_NEED_TO_UNLOCK");
if (isConfirmed(transactionId)) {
Transaction storage transaction = transactions[transactionId];
transaction.executed = true;
(bool success, ) = transaction.destination.call{value: transaction.value}(
transaction.data
);
if (success) emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
transaction.executed = false;
}
}
}
/** @dev Returns the confirmation status of a transaction.
* @param transactionId Transaction ID.
* @return Confirmation status.
*/
function isConfirmed(uint256 transactionId) public view returns (bool) {
uint256 count = 0;
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
count += 1;
}
if (count >= required) {
return true;
}
}
return false;
}
/* Web3 call functions */
/** @dev Returns number of confirmations of a transaction.
* @param transactionId Transaction ID.
* @return count Number of confirmations.
*/
function getConfirmationCount(uint256 transactionId) external view returns (uint256 count) {
for (uint256 i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
count += 1;
}
}
}
/** @dev Returns total number of transactions after filers are applied.
* @param pending Include pending transactions.
* @param executed Include executed transactions.
* @return count Total number of transactions after filters are applied.
*/
function getTransactionCount(bool pending, bool executed)
external
view
returns (uint256 count)
{
for (uint256 i = 0; i < transactionCount; i++) {
if ((pending && !transactions[i].executed) || (executed && transactions[i].executed)) {
count += 1;
}
}
}
/** @dev Returns list of owners.
* @return List of owner addresses.
*/
function getOwners() external view returns (address[] memory) {
return owners;
}
/** @dev Returns array with owner addresses, which confirmed transaction.
* @param transactionId Transaction ID.
* @return _confirmations Returns array of owner addresses.
*/
function getConfirmations(uint256 transactionId)
external
view
returns (address[] memory _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint256 count = 0;
uint256 i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
}

28
contracts/helper/NaiveFeeRateModel.sol Normal file
View File

@@ -0,0 +1,28 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {IFeeRateModel} from "../intf/IFeeRateModel.sol";
import {Ownable} from "../lib/Ownable.sol";
contract ConstFeeRateModel is Ownable, IFeeRateModel {
uint256 public _FEE_RATE_;
constructor(uint256 feeRate) public {
feeRate = _FEE_RATE_;
}
function setFeeRate(uint256 newFeeRate) external {
_FEE_RATE_ = newFeeRate;
}
function getFeeRate(uint256) external override view returns (uint256) {
return _FEE_RATE_;
}
}

25
contracts/helper/NaiveOracle.sol
View File

@@ -1,25 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {Ownable} from "../lib/Ownable.sol";
// Oracle only for test
contract NaiveOracle is Ownable {
uint256 public tokenPrice;
function setPrice(uint256 newPrice) external onlyOwner {
tokenPrice = newPrice;
}
function getPrice() external view returns (uint256) {
return tokenPrice;
}
}

72
contracts/helper/TestERC20.sol
View File

@@ -1,72 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
import {SafeMath} from "../lib/SafeMath.sol";
contract TestERC20 {
using SafeMath for uint256;
string public name;
uint8 public decimals;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(string memory _name, uint8 _decimals) public {
name = _name;
decimals = _decimals;
}
function transfer(address to, uint256 amount) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[msg.sender], "BALANCE_NOT_ENOUGH");
balances[msg.sender] = balances[msg.sender].sub(amount);
balances[to] = balances[to].add(amount);
emit Transfer(msg.sender, to, amount);
return true;
}
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function transferFrom(
address from,
address to,
uint256 amount
) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[from], "BALANCE_NOT_ENOUGH");
require(amount <= allowed[from][msg.sender], "ALLOWANCE_NOT_ENOUGH");
balances[from] = balances[from].sub(amount);
balances[to] = balances[to].add(amount);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(amount);
emit Transfer(from, to, amount);
return true;
}
function approve(address spender, uint256 amount) public returns (bool) {
allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return allowed[owner][spender];
}
function mint(address account, uint256 amount) external {
balances[account] = balances[account].add(amount);
}
}

77
contracts/helper/TestWETH.sol
View File

@@ -1,77 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
contract WETH9 {
string public name = "Wrapped Ether";
string public symbol = "WETH";
uint8 public decimals = 18;
event Approval(address indexed src, address indexed guy, uint256 wad);
event Transfer(address indexed src, address indexed dst, uint256 wad);
event Deposit(address indexed dst, uint256 wad);
event Withdrawal(address indexed src, uint256 wad);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
fallback() external payable {
deposit();
}
receive() external payable {
deposit();
}
function deposit() public payable {
balanceOf[msg.sender] += msg.value;
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint256 wad) public {
require(balanceOf[msg.sender] >= wad);
balanceOf[msg.sender] -= wad;
msg.sender.transfer(wad);
emit Withdrawal(msg.sender, wad);
}
function totalSupply() public view returns (uint256) {
return address(this).balance;
}
function approve(address guy, uint256 wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint256 wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(
address src,
address dst,
uint256 wad
) public returns (bool) {
require(balanceOf[src] >= wad);
if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
Transfer(src, dst, wad);
return true;
}
}

165
contracts/helper/UniswapArbitrageur.sol
View File

@@ -1,165 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {Ownable} from "../lib/Ownable.sol";
import {IDODO} from "../intf/IDODO.sol";
import {IERC20} from "../intf/IERC20.sol";
import {SafeERC20} from "../lib/SafeERC20.sol";
import {SafeMath} from "../lib/SafeMath.sol";
interface IUniswapV2Pair {
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
}
contract UniswapArbitrageur {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public _UNISWAP_;
address public _DODO_;
address public _BASE_;
address public _QUOTE_;
bool public _REVERSE_; // true if dodo.baseToken=uniswap.token0
constructor(address _uniswap, address _dodo) public {
_UNISWAP_ = _uniswap;
_DODO_ = _dodo;
_BASE_ = IDODO(_DODO_)._BASE_TOKEN_();
_QUOTE_ = IDODO(_DODO_)._QUOTE_TOKEN_();
address token0 = IUniswapV2Pair(_UNISWAP_).token0();
address token1 = IUniswapV2Pair(_UNISWAP_).token1();
if (token0 == _BASE_ && token1 == _QUOTE_) {
_REVERSE_ = false;
} else if (token0 == _QUOTE_ && token1 == _BASE_) {
_REVERSE_ = true;
} else {
require(true, "DODO_UNISWAP_NOT_MATCH");
}
IERC20(_BASE_).approve(_DODO_, uint256(-1));
IERC20(_QUOTE_).approve(_DODO_, uint256(-1));
}
function executeBuyArbitrage(uint256 baseAmount) external returns (uint256 quoteProfit) {
IDODO(_DODO_).buyBaseToken(baseAmount, uint256(-1), "0xd");
quoteProfit = IERC20(_QUOTE_).balanceOf(address(this));
IERC20(_QUOTE_).transfer(msg.sender, quoteProfit);
return quoteProfit;
}
function executeSellArbitrage(uint256 baseAmount) external returns (uint256 baseProfit) {
IDODO(_DODO_).sellBaseToken(baseAmount, 0, "0xd");
baseProfit = IERC20(_BASE_).balanceOf(address(this));
IERC20(_BASE_).transfer(msg.sender, baseProfit);
return baseProfit;
}
function dodoCall(
bool isDODOBuy,
uint256 baseAmount,
uint256 quoteAmount,
bytes calldata
) external {
require(msg.sender == _DODO_, "WRONG_DODO");
if (_REVERSE_) {
_inverseArbitrage(isDODOBuy, baseAmount, quoteAmount);
} else {
_arbitrage(isDODOBuy, baseAmount, quoteAmount);
}
}
function _inverseArbitrage(
bool isDODOBuy,
uint256 baseAmount,
uint256 quoteAmount
) internal {
(uint112 _reserve0, uint112 _reserve1, ) = IUniswapV2Pair(_UNISWAP_).getReserves();
uint256 token0Balance = uint256(_reserve0);
uint256 token1Balance = uint256(_reserve1);
uint256 token0Amount;
uint256 token1Amount;
if (isDODOBuy) {
IERC20(_BASE_).transfer(_UNISWAP_, baseAmount);
// transfer token1 into uniswap
uint256 newToken0Balance = token0Balance.mul(token1Balance).div(
token1Balance.add(baseAmount)
);
token0Amount = token0Balance.sub(newToken0Balance).mul(9969).div(10000); // mul 0.9969
require(token0Amount > quoteAmount, "NOT_PROFITABLE");
IUniswapV2Pair(_UNISWAP_).swap(token0Amount, token1Amount, address(this), "");
} else {
IERC20(_QUOTE_).transfer(_UNISWAP_, quoteAmount);
// transfer token0 into uniswap
uint256 newToken1Balance = token0Balance.mul(token1Balance).div(
token0Balance.add(quoteAmount)
);
token1Amount = token1Balance.sub(newToken1Balance).mul(9969).div(10000); // mul 0.9969
require(token1Amount > baseAmount, "NOT_PROFITABLE");
IUniswapV2Pair(_UNISWAP_).swap(token0Amount, token1Amount, address(this), "");
}
}
function _arbitrage(
bool isDODOBuy,
uint256 baseAmount,
uint256 quoteAmount
) internal {
(uint112 _reserve0, uint112 _reserve1, ) = IUniswapV2Pair(_UNISWAP_).getReserves();
uint256 token0Balance = uint256(_reserve0);
uint256 token1Balance = uint256(_reserve1);
uint256 token0Amount;
uint256 token1Amount;
if (isDODOBuy) {
IERC20(_BASE_).transfer(_UNISWAP_, baseAmount);
// transfer token0 into uniswap
uint256 newToken1Balance = token1Balance.mul(token0Balance).div(
token0Balance.add(baseAmount)
);
token1Amount = token1Balance.sub(newToken1Balance).mul(9969).div(10000); // mul 0.9969
require(token1Amount > quoteAmount, "NOT_PROFITABLE");
IUniswapV2Pair(_UNISWAP_).swap(token0Amount, token1Amount, address(this), "");
} else {
IERC20(_QUOTE_).transfer(_UNISWAP_, quoteAmount);
// transfer token1 into uniswap
uint256 newToken0Balance = token1Balance.mul(token0Balance).div(
token1Balance.add(quoteAmount)
);
token0Amount = token0Balance.sub(newToken0Balance).mul(9969).div(10000); // mul 0.9969
require(token0Amount > baseAmount, "NOT_PROFITABLE");
IUniswapV2Pair(_UNISWAP_).swap(token0Amount, token1Amount, address(this), "");
}
}
function retrieve(address token, uint256 amount) external {
IERC20(token).safeTransfer(msg.sender, amount);
}
}

636
contracts/helper/UniswapV2.sol
View File

@@ -1,636 +0,0 @@
/**
*Submitted for verification at Etherscan.io on 2020-05-05
*/
// File: contracts/interfaces/IUniswapV2Pair.sol
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// File: contracts/interfaces/IUniswapV2ERC20.sol
pragma solidity >=0.5.0;
interface IUniswapV2ERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
}
// File: contracts/libraries/SafeMath.sol
pragma solidity 0.6.9;
// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
// File: contracts/UniswapV2ERC20.sol
pragma solidity 0.6.9;
contract UniswapV2ERC20 {
using SafeMath for uint256;
string public constant name = "Uniswap V2";
string public constant symbol = "UNI-V2";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(
address owner,
address spender,
uint256 value
) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(
address from,
address to,
uint256 value
) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool) {
if (allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external {
require(deadline >= block.timestamp, "UniswapV2: EXPIRED");
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR,
keccak256(
abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline)
)
)
);
address recoveredAddress = ecrecover(digest, v, r, s);
require(
recoveredAddress != address(0) && recoveredAddress == owner,
"UniswapV2: INVALID_SIGNATURE"
);
_approve(owner, spender, value);
}
}
// File: contracts/libraries/Math.sol
pragma solidity 0.6.9;
// a library for performing various math operations
library Math {
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// File: contracts/libraries/UQ112x112.sol
pragma solidity 0.6.9;
// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
// File: contracts/interfaces/IERC20.sol
pragma solidity >=0.5.0;
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
// File: contracts/interfaces/IUniswapV2Factory.sol
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// File: contracts/interfaces/IUniswapV2Callee.sol
pragma solidity >=0.5.0;
interface IUniswapV2Callee {
function uniswapV2Call(
address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external;
}
// File: contracts/UniswapV2Pair.sol
pragma solidity 0.6.9;
contract UniswapV2Pair is UniswapV2ERC20 {
using SafeMath for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
require(unlocked == 1, "UniswapV2: LOCKED");
unlocked = 0;
_;
unlocked = 1;
}
function getReserves()
public
view
returns (
uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast
)
{
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(
address token,
address to,
uint256 value
) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(
success && (data.length == 0 || abi.decode(data, (bool))),
"UniswapV2: TRANSFER_FAILED"
);
}
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, "UniswapV2: FORBIDDEN"); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(
uint256 balance0,
uint256 balance1,
uint112 _reserve0,
uint112 _reserve1
) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), "UniswapV2: OVERFLOW");
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast +=
uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) *
timeElapsed;
price1CumulativeLast +=
uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) *
timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IUniswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
uint256 balance0 = IERC20(token0).balanceOf(address(this));
uint256 balance1 = IERC20(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(
amount0.mul(_totalSupply) / _reserve0,
amount1.mul(_totalSupply) / _reserve1
);
}
require(liquidity > 0, "UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED");
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint256 balance0 = IERC20(_token0).balanceOf(address(this));
uint256 balance1 = IERC20(_token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, "UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED");
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external lock {
require(amount0Out > 0 || amount1Out > 0, "UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1, ) = getReserves(); // gas savings
require(
amount0Out < _reserve0 && amount1Out < _reserve1,
"UniswapV2: INSUFFICIENT_LIQUIDITY"
);
uint256 balance0;
uint256 balance1;
{
// scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, "UniswapV2: INVALID_TO");
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0)
IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint256 amount0In = balance0 > _reserve0 - amount0Out
? balance0 - (_reserve0 - amount0Out)
: 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out
? balance1 - (_reserve1 - amount1Out)
: 0;
require(amount0In > 0 || amount1In > 0, "UniswapV2: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(
balance0Adjusted.mul(balance1Adjusted) >=
uint256(_reserve0).mul(_reserve1).mul(1000**2),
"UniswapV2: K"
);
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(
IERC20(token0).balanceOf(address(this)),
IERC20(token1).balanceOf(address(this)),
reserve0,
reserve1
);
}
}