Contract Name:
DecentraTokens
Contract Source Code:
// SPDX-License-Identifier: UNLICENSED
/**
#Decentra-Tokens
TG:
Website: https://decentra-tokens.com/
10% tax buys and sells
1% Reflection yield
5% Development/team
2% is sent to the DELO mega draw wallet
2% is used to buy the meme lottery token
*/
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
abstract contract RandomNumberConsumer is VRFConsumerBase {
bytes32 internal keyHash;
uint256 internal fee;
uint256 public randomResult;
//contracts: https://docs.chain.link/docs/vrf-contracts/
//faucets: https://docs.chain.link/docs/link-token-contracts/
constructor(address _vrfCoordinator, address _link, bytes32 _keyHash, uint256 _fee)
VRFConsumerBase(
_vrfCoordinator, // VRF Coordinator
_link // LINK Token
)
{
keyHash = _keyHash;
fee = _fee; // 0.1 LINK for testnet, 2 LINK for Live (Varies by network)
}
/**
* Requests randomness
*/
function getRandomNumber() internal returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK - fill contract with faucet");
return requestRandomness(keyHash, fee);
}
}
contract DecentraTokens is Context, IERC20, Ownable, RandomNumberConsumer {
using Address for address;
//tracking addresses for lotto entry using mappings
uint256 private numAddresses = 0;
mapping (uint256 => address) private _addressList;
mapping (address => bool) private _AddressExists;
//
//token amounts
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
//
//token config
string private _name = "DE-FEG";
string private _symbol = "DFEG";
uint8 private _decimals = 9;
uint256 public _taxFee = 1;
uint256 private _previousTaxFee = _taxFee;
uint256 public _jackpotFee = 2;
uint256 private _previousJackpotFee = _jackpotFee;
uint256 public _ecosystemLottoDevFee = 7;
uint256 private _previousEcosystemLottoDevFee = _ecosystemLottoDevFee;
uint256 public _percentOfSwapIsEcosystem = 22;
uint256 public _percentOfSwapIsLotto = 22;
uint256 public _percentOfSwapIsMarketing = 22;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1 * 10**7 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//
//Contract init and sniper config
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address public JACKPOT_TOKEN_ADDRESS;
IERC20 jackpotToken;
uint8 private _jackpotTokenDecimals;
mapping (address => bool) private _isSniperOrBlacklisted;
bool private sniperProtection = true;
bool public _hasLiqBeenAdded = false;
uint256 private _liqAddBlock = 0;
uint256 public snipersCaught = 0;
uint256 private snipeBlockAmt = 2;
//
//excludes
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping (address => bool) private _isExcludedFromMaxWallet;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isLottoExcluded;
address[] private _excluded;
//
//payable wallets
address payable private _devWallet;
address payable private _marketingWallet;
address payable private _ecosystemWallet;
//lotto config
bool public lottoOn = true;
uint256 public lottoJackpotAmount;
uint256 public minLottoBalance = 1 * 10**4 * 10**9;
mapping(uint256 => Winner) public lottoWinners;
mapping(address => uint256) public walletWinAmount;
uint256 public numWinners = 0;
LotteryState public state;
uint256 public totalWon = 0;
//
//other config and members
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndDistribute;
bool public swapAndDistributeEnabled = false;
uint256 public _maxTxAmount = 5 * 10**4 * 10**9; //0.5%
uint256 public _maxWalletAmount = 15 * 10**4 * 10**9; //1.5%
uint256 public numTokensSellToDistribute = 1 * 10**4 * 10**9; //0.1%
bytes32 private requestId;
//
//events
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndDistributeEnabledUpdated(bool enabled);
event LottoEnabledUpdated(bool enabled);
event SwapAndDistribute(
uint256 tokensSwapped,
uint256 jackpotETHAmount,
uint256 ecosystemETHAmount,
uint256 devETHAmount
);
event SniperCaught(address sniperAddress);
event LotteryStateChanged(LotteryState newState);
event GetRandom(bytes32 requestId);
event GotRandom(uint256 randomNumber);
event WinnerPaid(address indexed user, uint256 amount);
//
//enums
enum LotteryState{
Open,
GettingRandom,
GotRandom
}
//
//structs
struct Winner {
address winner;
uint256 amount;
}
//
//modifiers
modifier lockTheSwap {
inSwapAndDistribute = true;
_;
inSwapAndDistribute = false;
}
//
constructor (address router, address devWallet, address marketingWallet, address ecosystemWallet, address jackpotTokenAddress_IN, uint8 jackpotTokenDecimals_IN, uint256 lottoJackpotAmount_IN)
RandomNumberConsumer(
0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, //vrfCoordinator ETH mainnet
0x514910771AF9Ca656af840dff83E8264EcF986CA, // link address ETH mainnet
0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445, //key hash ETH mainnet
2 * 10 ** 18 //fee ETH mainnet
) public {
_rOwned[owner()] = _rTotal;
JACKPOT_TOKEN_ADDRESS = jackpotTokenAddress_IN;
_jackpotTokenDecimals = jackpotTokenDecimals_IN;
lottoJackpotAmount = lottoJackpotAmount_IN * 10**jackpotTokenDecimals_IN;
jackpotToken = IERC20(JACKPOT_TOKEN_ADDRESS);
addAddress(owner());
_devWallet = payable(devWallet);
_marketingWallet = payable(marketingWallet);
_ecosystemWallet = payable(ecosystemWallet);
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(router);
// Create a uniswap pair for this new token
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
// set the rest of the contract variables
uniswapV2Router = _uniswapV2Router;
//exclude owner, ecosystem and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[_devWallet] = true;
_isExcludedFromFee[_ecosystemWallet] = true;
_isExcludedFromFee[_marketingWallet] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromMaxTx[owner()] = true;
_isExcludedFromMaxTx[_devWallet] = true;
_isExcludedFromMaxTx[_ecosystemWallet] = true;
_isExcludedFromMaxTx[_marketingWallet] = true;
_isExcludedFromMaxWallet[owner()] = true;
_isExcludedFromMaxWallet[_devWallet] = true;
_isExcludedFromMaxWallet[_ecosystemWallet] = true;
_isExcludedFromMaxWallet[_marketingWallet] = true;
_isExcludedFromMaxWallet[address(this)] = true;
_isExcludedFromMaxWallet[DEAD] = true;
_isLottoExcluded[owner()] = true;
_isLottoExcluded[_devWallet] = true;
_isLottoExcluded[_ecosystemWallet] = true;
_isLottoExcluded[_marketingWallet] = true;
_isLottoExcluded[address(this)] = true;
_isLottoExcluded[uniswapV2Pair] = true;
_isLottoExcluded[router] = true;
emit Transfer(address(0), owner(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()]-(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender]+(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender]-(subtractedValue));
return true;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender]-(rAmount);
_rTotal = _rTotal-(rAmount);
_tFeeTotal = _tFeeTotal+(tAmount);
}
function excludeFromLottoRewards(address addy) public onlyOwner {
require(_isLottoExcluded[addy] == false, "User already excluded from lotto rewards");
_isLottoExcluded[addy] = true;
}
function excludeFromMaxWallet(address addy) public onlyOwner {
_isExcludedFromMaxWallet[addy] = true;
}
function includeInMaxWallet(address addy) public onlyOwner {
_isExcludedFromMaxWallet[addy] = true;
}
function includeInLottoRewards(address addy) public onlyOwner {
require(_isLottoExcluded[addy] == true, "User already included in lotto rewards");
_isLottoExcluded[addy] = false;
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount/(currentRate);
}
function setDevAddress(address dev) public onlyOwner() {
_devWallet = payable(dev);
}
function setMarketingAddress(address marketing) public onlyOwner() {
_marketingWallet = payable(marketing);
}
function setEcosystemAddress(address ecosystem) external onlyOwner {
_ecosystemWallet = payable(ecosystem);
}
function setJackpotTokenAddress(address token, uint8 decimalsIn) external onlyOwner {
JACKPOT_TOKEN_ADDRESS = token;
_jackpotTokenDecimals = decimalsIn;
jackpotToken = IERC20(JACKPOT_TOKEN_ADDRESS);
}
function setlottoJackpotAmount(uint256 minBalance) public onlyOwner() {
lottoJackpotAmount = minBalance * 10**_jackpotTokenDecimals;
}
function setMinLottoBalance(uint256 minBalance) public onlyOwner() {
minLottoBalance = minBalance * 10**_decimals;
}
function setRouterAddress(address newRouter) external onlyOwner() {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(newRouter);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
_isLottoExcluded[uniswapV2Pair] = true;
_isLottoExcluded[newRouter] = true;
}
function excludeFromReward(address account) public onlyOwner() {
// require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already included");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tLotto) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender]-(tAmount);
_rOwned[sender] = _rOwned[sender]-(rAmount);
_tOwned[recipient] = _tOwned[recipient]+(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient]+(rTransferAmount);
_takeEcosystem(tLiquidity);
_takeLotto(tLotto);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function excludeFromMaxTx(address account) public onlyOwner {
_isExcludedFromMaxTx[account] = true;
}
function includeInMaxTx(address account) public onlyOwner {
_isExcludedFromMaxTx[account] = false;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setReflectionTaxPercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLottoTaxPercent(uint256 lottoFee) external onlyOwner() {
_jackpotFee = lottoFee;
}
function setPercentOfSwapIsEcosystem(uint256 percentOfSwapIsEcosystem) external onlyOwner() {
_percentOfSwapIsEcosystem = percentOfSwapIsEcosystem;
}
function setPercentOfSwapIsMarketing(uint256 percentOfSwapIsMarketing) external onlyOwner() {
_percentOfSwapIsMarketing = percentOfSwapIsMarketing;
}
function setEcosystemLottoDevFee(uint256 ecosystemLottoDevFee) external onlyOwner() {
_ecosystemLottoDevFee = ecosystemLottoDevFee;
}
function setLottoFeePercent(uint256 percentOfSwapIsLotto) external onlyOwner() {
_percentOfSwapIsLotto = percentOfSwapIsLotto;
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
_maxTxAmount = maxTxAmount*10**_decimals;
}
function setSwapAndDistributeEnabled(bool _enabled) public onlyOwner {
swapAndDistributeEnabled = _enabled;
emit SwapAndDistributeEnabledUpdated(_enabled);
}
function setLottoEnabled(bool _lottoOn) public onlyOwner {
lottoOn = _lottoOn;
emit LottoEnabledUpdated(_lottoOn);
}
function multiSender(address[] calldata _addresses, uint256[] calldata _values) external returns (bool) {
require(_addresses.length == _values.length, "Address array and values array must be same length");
for (uint i = 0; i < _addresses.length; i++) {
require(_addresses[i] != address(0), "Address invalid");
require(_values[i] > 0, "Value invalid");
IERC20(address(this)).transferFrom(msg.sender, _addresses[i], _values[i]);
}
return true;
}
//withdraw dust leftover from swaps
function withdrawETH(uint256 amount) external onlyOwner {
payable(msg.sender).transfer(amount);
}
//withdraw token link or trapped tokens
function withdrawToken(address _address, uint256 amount) external onlyOwner {
// Ensure requested tokens isn't Jackpot token (cannot withdraw the pot)
require(_address != JACKPOT_TOKEN_ADDRESS, "Cannot withdraw Lottery pot");
require(_address != address(this), "Cannot withdraw platform token");
IERC20 token = IERC20(_address);
token.transfer(msg.sender, amount);
}
function getStats() external view returns(uint256, uint256, uint256, LotteryState, uint256) {
return(lottoJackpotAmount, jackpotToken.balanceOf(address(this)), numWinners, state, totalWon);
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal-(rFee);
_tFeeTotal = _tFeeTotal+(tFee);
}
struct TData {
uint256 tAmount;
uint256 tFee;
uint256 tLiquidity;
uint256 tLotto;
uint256 currentRate;
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, TData memory data) = _getTValues(tAmount);
data.tAmount = tAmount;
data.currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(data);
return (rAmount, rTransferAmount, rFee, tTransferAmount, data.tFee, data.tLiquidity, data.tLotto);
}
function _getTValues(uint256 tAmount) private view returns (uint256, TData memory) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tLotto = calculateLottoFee(tAmount);
uint256 tTransferAmount = tAmount-(tFee)-(tLiquidity)-(tLotto);
return (tTransferAmount, TData(0, tFee, tLiquidity, tLotto, 0));
}
function _getRValues( TData memory _data) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = _data.tAmount*(_data.currentRate);
uint256 rFee = _data.tFee*(_data.currentRate);
uint256 rLiquidity = _data.tLiquidity*(_data.currentRate);
uint256 rLotto = _data.tLotto*(_data.currentRate);
uint256 rTransferAmount = rAmount-(rFee)-(rLiquidity)-(rLotto);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply/(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply-(_rOwned[_excluded[i]]);
tSupply = tSupply-(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal/(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeEcosystem(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity*currentRate;
_rOwned[address(this)] = _rOwned[address(this)]+rLiquidity;
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)]+tLiquidity;
}
function addAddress(address adr) private {
if(!_AddressExists[adr]){
_AddressExists[adr] = true;
_addressList[numAddresses] = adr;
numAddresses++;
}
}
function _takeLotto(uint256 tLotto) private {
uint256 currentRate = _getRate();
uint256 rLotto = tLotto*currentRate;
_rOwned[address(this)] = _rOwned[address(this)]+rLotto;
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)]+tLotto;
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount*(_taxFee)/(
10**2
);
}
function calculateLottoFee(uint256 _amount) private view returns (uint256) {
return _amount*(_jackpotFee)/(
10**2
);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount*(_ecosystemLottoDevFee)/(
10**2
);
}
function removeAllFee() private {
if(_taxFee == 0 && _ecosystemLottoDevFee == 0 && _jackpotFee == 0) return;
_previousTaxFee = _taxFee;
_previousJackpotFee = _jackpotFee;
_previousEcosystemLottoDevFee = _ecosystemLottoDevFee;
_taxFee = 0;
_jackpotFee = 0;
_ecosystemLottoDevFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_jackpotFee = _previousJackpotFee;
_ecosystemLottoDevFee = _previousEcosystemLottoDevFee;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function isExcludedFromMaxTx(address account) public view returns(bool) {
return _isExcludedFromMaxTx[account];
}
function setNumTokensSellToDistribute(uint256 _numTokensSellToDistribute) public onlyOwner{
numTokensSellToDistribute = _numTokensSellToDistribute*10**_decimals;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(from != owner() && to != owner() && !_isExcludedFromMaxTx[from] && !_isExcludedFromMaxTx[to])
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if(from != owner() && to != owner() && !_isExcludedFromMaxWallet[to] && from == uniswapV2Pair)
require(balanceOf(to)+(amount) <= _maxWalletAmount, "Transfer amount makes wallet hold more than max.");
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToDistribute;
if (
overMinTokenBalance &&
!inSwapAndDistribute &&
from != uniswapV2Pair &&
swapAndDistributeEnabled
) {
contractTokenBalance = numTokensSellToDistribute;
//swa and distribute tokens
swapAndDistribute(contractTokenBalance);
}else{
//check if random got to draw winner here so as not to do too much in one transaction avoiding of gas exceptions
if (state == LotteryState.GotRandom && lottoOn){
drawWinner();
}
}
//check jackpot threshold and lotto state here to get random
uint256 jackpotTokenBalance = jackpotToken.balanceOf(address(this));
bool overMinJackpotBalance = jackpotTokenBalance >= lottoJackpotAmount;
if (
overMinJackpotBalance &&
state == LotteryState.Open &&
LINK.balanceOf(address(this)) >= fee &&
lottoOn
) {
_changeState(LotteryState.GettingRandom);
requestId = getRandomNumber();
emit GetRandom(requestId);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
addAddress(from);
addAddress(to);
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function getRandomAddress(uint32 seed) private view returns(address) {
return _addressList[(uint256(keccak256(abi.encode(randomResult, seed))) % numAddresses)];
}
function drawWinner() private {
_changeState(LotteryState.Open);
//seed for abi encoding random number
uint32 seed = 1;
address randomAddress = getRandomAddress(seed);
//get more random addresses until an address qualifies to win
while (balanceOf(randomAddress) < minLottoBalance || _isLottoExcluded[randomAddress]){
seed++;
randomAddress = getRandomAddress(seed);
if(seed > 40){
//cap it at 40 iterations so we don't get infinite loop or out of gas exception
break;
}
}
uint256 jackpotAmount = jackpotToken.balanceOf(address(this));
jackpotToken.transfer(randomAddress, jackpotAmount);
numWinners++;
lottoWinners[numWinners] = Winner(randomAddress, jackpotAmount);
walletWinAmount[randomAddress] += jackpotAmount;
totalWon += jackpotAmount;
emit WinnerPaid(randomAddress, jackpotAmount);
}
function swapAndDistribute(uint256 contractTokenBalance) private lockTheSwap {
//SWAP TO ETH
uint256 initialBalance = address(this).balance;
swapTokensForEth(contractTokenBalance);
//amount of ETH swapped into
uint256 deltaBalance = address(this).balance - initialBalance;
//get the percentage split for Ecosystem, and Lotto
uint256 ecosystemETHAmount = (deltaBalance*_percentOfSwapIsEcosystem)/100;
uint256 jackpotETHAmount = (deltaBalance*_percentOfSwapIsLotto)/100;
uint256 marketingETHAmount = (deltaBalance*_percentOfSwapIsMarketing)/100;
//swap to jackpot token
swapEthForJackpotToken(jackpotETHAmount);
//send ETH to ecosystem and marketing, and dev
_ecosystemWallet.transfer(ecosystemETHAmount);
_marketingWallet.transfer(marketingETHAmount);
_devWallet.transfer(deltaBalance-ecosystemETHAmount-jackpotETHAmount-marketingETHAmount);
emit SwapAndDistribute(contractTokenBalance, jackpotETHAmount, ecosystemETHAmount, deltaBalance-ecosystemETHAmount-jackpotETHAmount);
}
function swapTokensForEth(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
// make the swap
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function swapEthForJackpotToken(uint256 ethAmount) private {
// generate the uniswap pair path of weth -> token
address[] memory path = new address[](2);
path[0] = uniswapV2Router.WETH();
path[1] = JACKPOT_TOKEN_ADDRESS;
// make the swap
uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(
0, // accept any amount of token
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(uniswapV2Router), tokenAmount);
// add the liquidity
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp
);
}
function _checkLiquidityAdd(address from, address to) private {
require(!_hasLiqBeenAdded, "Liquidity already added and marked.");
if (!_hasLimits(from, to) && to == uniswapV2Pair) {
_liqAddBlock = block.number;
_hasLiqBeenAdded = true;
swapAndDistributeEnabled = true;
emit SwapAndDistributeEnabledUpdated(true);
}
}
function _hasLimits(address from, address to) private view returns (bool) {
return from != owner()
&& to != owner()
&& to != DEAD
&& to != address(0)
&& from != address(this);
}
function excludeSniper(address sniper) public onlyOwner{
require(_isSniperOrBlacklisted[sniper], "Address not considered a sniper.");
_isSniperOrBlacklisted[sniper] = false;
snipersCaught --;
}
function includeSniper(address sniper) public onlyOwner{
require(!_isSniperOrBlacklisted[sniper], "Address already considered a sniper.");
_isSniperOrBlacklisted[sniper] = true;
snipersCaught ++;
}
function setSniperProtection(bool _sniperProtection) public onlyOwner{
sniperProtection = _sniperProtection;
}
//this method is responsible for taking all fee, if takeFee is true and checking/banning bots
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if (sniperProtection){
if (_isSniperOrBlacklisted[sender] || _isSniperOrBlacklisted[recipient]) {
revert("Sniper rejected.");
}
if (!_hasLiqBeenAdded) {
_checkLiquidityAdd(sender, recipient);
if (!_hasLiqBeenAdded && _hasLimits(sender, recipient)) {
revert("Only owner can transfer at this time.");
}
} else {
if (_liqAddBlock > 0
&& sender == uniswapV2Pair
&& _hasLimits(sender, recipient)
) {
if (block.number - _liqAddBlock < snipeBlockAmt) {
_isSniperOrBlacklisted[recipient] = true;
snipersCaught ++;
emit SniperCaught(recipient);
}
}
}
}
if(!takeFee)
removeAllFee();
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tLotto) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender]-(rAmount);
_rOwned[recipient] = _rOwned[recipient]+(rTransferAmount);
_takeEcosystem(tLiquidity);
_takeLotto(tLotto);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tLotto) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender]-(rAmount);
_tOwned[recipient] = _tOwned[recipient]+(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient]+(rTransferAmount);
_takeEcosystem(tLiquidity);
_takeLotto(tLotto);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tLotto) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender]-(tAmount);
_rOwned[sender] = _rOwned[sender]-(rAmount);
_rOwned[recipient] = _rOwned[recipient]+(rTransferAmount);
_takeEcosystem(tLiquidity);
_takeLotto(tLotto);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 _requestId, uint256 randomness) internal override {
require (requestId == _requestId, "requestId doesn't match");
randomResult = randomness;
_changeState(LotteryState.GotRandom);
emit GotRandom(randomResult);
}
function _changeState(LotteryState _newState) private {
state = _newState;
emit LotteryStateChanged(state);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity >=0.6.2;
import './IUniswapV2Router01.sol';
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./interfaces/LinkTokenInterface.sol";
import "./VRFRequestIDBase.sol";
/** ****************************************************************************
* @notice Interface for contracts using VRF randomness
* *****************************************************************************
* @dev PURPOSE
*
* @dev Reggie the Random Oracle (not his real job) wants to provide randomness
* @dev to Vera the verifier in such a way that Vera can be sure he's not
* @dev making his output up to suit himself. Reggie provides Vera a public key
* @dev to which he knows the secret key. Each time Vera provides a seed to
* @dev Reggie, he gives back a value which is computed completely
* @dev deterministically from the seed and the secret key.
*
* @dev Reggie provides a proof by which Vera can verify that the output was
* @dev correctly computed once Reggie tells it to her, but without that proof,
* @dev the output is indistinguishable to her from a uniform random sample
* @dev from the output space.
*
* @dev The purpose of this contract is to make it easy for unrelated contracts
* @dev to talk to Vera the verifier about the work Reggie is doing, to provide
* @dev simple access to a verifiable source of randomness.
* *****************************************************************************
* @dev USAGE
*
* @dev Calling contracts must inherit from VRFConsumerBase, and can
* @dev initialize VRFConsumerBase's attributes in their constructor as
* @dev shown:
*
* @dev contract VRFConsumer {
* @dev constuctor(<other arguments>, address _vrfCoordinator, address _link)
* @dev VRFConsumerBase(_vrfCoordinator, _link) public {
* @dev <initialization with other arguments goes here>
* @dev }
* @dev }
*
* @dev The oracle will have given you an ID for the VRF keypair they have
* @dev committed to (let's call it keyHash), and have told you the minimum LINK
* @dev price for VRF service. Make sure your contract has sufficient LINK, and
* @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
* @dev want to generate randomness from.
*
* @dev Once the VRFCoordinator has received and validated the oracle's response
* @dev to your request, it will call your contract's fulfillRandomness method.
*
* @dev The randomness argument to fulfillRandomness is the actual random value
* @dev generated from your seed.
*
* @dev The requestId argument is generated from the keyHash and the seed by
* @dev makeRequestId(keyHash, seed). If your contract could have concurrent
* @dev requests open, you can use the requestId to track which seed is
* @dev associated with which randomness. See VRFRequestIDBase.sol for more
* @dev details. (See "SECURITY CONSIDERATIONS" for principles to keep in mind,
* @dev if your contract could have multiple requests in flight simultaneously.)
*
* @dev Colliding `requestId`s are cryptographically impossible as long as seeds
* @dev differ. (Which is critical to making unpredictable randomness! See the
* @dev next section.)
*
* *****************************************************************************
* @dev SECURITY CONSIDERATIONS
*
* @dev A method with the ability to call your fulfillRandomness method directly
* @dev could spoof a VRF response with any random value, so it's critical that
* @dev it cannot be directly called by anything other than this base contract
* @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
*
* @dev For your users to trust that your contract's random behavior is free
* @dev from malicious interference, it's best if you can write it so that all
* @dev behaviors implied by a VRF response are executed *during* your
* @dev fulfillRandomness method. If your contract must store the response (or
* @dev anything derived from it) and use it later, you must ensure that any
* @dev user-significant behavior which depends on that stored value cannot be
* @dev manipulated by a subsequent VRF request.
*
* @dev Similarly, both miners and the VRF oracle itself have some influence
* @dev over the order in which VRF responses appear on the blockchain, so if
* @dev your contract could have multiple VRF requests in flight simultaneously,
* @dev you must ensure that the order in which the VRF responses arrive cannot
* @dev be used to manipulate your contract's user-significant behavior.
*
* @dev Since the ultimate input to the VRF is mixed with the block hash of the
* @dev block in which the request is made, user-provided seeds have no impact
* @dev on its economic security properties. They are only included for API
* @dev compatability with previous versions of this contract.
*
* @dev Since the block hash of the block which contains the requestRandomness
* @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
* @dev miner could, in principle, fork the blockchain to evict the block
* @dev containing the request, forcing the request to be included in a
* @dev different block with a different hash, and therefore a different input
* @dev to the VRF. However, such an attack would incur a substantial economic
* @dev cost. This cost scales with the number of blocks the VRF oracle waits
* @dev until it calls responds to a request.
*/
abstract contract VRFConsumerBase is VRFRequestIDBase {
/**
* @notice fulfillRandomness handles the VRF response. Your contract must
* @notice implement it. See "SECURITY CONSIDERATIONS" above for important
* @notice principles to keep in mind when implementing your fulfillRandomness
* @notice method.
*
* @dev VRFConsumerBase expects its subcontracts to have a method with this
* @dev signature, and will call it once it has verified the proof
* @dev associated with the randomness. (It is triggered via a call to
* @dev rawFulfillRandomness, below.)
*
* @param requestId The Id initially returned by requestRandomness
* @param randomness the VRF output
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;
/**
* @dev In order to keep backwards compatibility we have kept the user
* seed field around. We remove the use of it because given that the blockhash
* enters later, it overrides whatever randomness the used seed provides.
* Given that it adds no security, and can easily lead to misunderstandings,
* we have removed it from usage and can now provide a simpler API.
*/
uint256 private constant USER_SEED_PLACEHOLDER = 0;
/**
* @notice requestRandomness initiates a request for VRF output given _seed
*
* @dev The fulfillRandomness method receives the output, once it's provided
* @dev by the Oracle, and verified by the vrfCoordinator.
*
* @dev The _keyHash must already be registered with the VRFCoordinator, and
* @dev the _fee must exceed the fee specified during registration of the
* @dev _keyHash.
*
* @dev The _seed parameter is vestigial, and is kept only for API
* @dev compatibility with older versions. It can't *hurt* to mix in some of
* @dev your own randomness, here, but it's not necessary because the VRF
* @dev oracle will mix the hash of the block containing your request into the
* @dev VRF seed it ultimately uses.
*
* @param _keyHash ID of public key against which randomness is generated
* @param _fee The amount of LINK to send with the request
*
* @return requestId unique ID for this request
*
* @dev The returned requestId can be used to distinguish responses to
* @dev concurrent requests. It is passed as the first argument to
* @dev fulfillRandomness.
*/
function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
// This is the seed passed to VRFCoordinator. The oracle will mix this with
// the hash of the block containing this request to obtain the seed/input
// which is finally passed to the VRF cryptographic machinery.
uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
// nonces[_keyHash] must stay in sync with
// VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
// successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
// This provides protection against the user repeating their input seed,
// which would result in a predictable/duplicate output, if multiple such
// requests appeared in the same block.
nonces[_keyHash] = nonces[_keyHash] + 1;
return makeRequestId(_keyHash, vRFSeed);
}
LinkTokenInterface internal immutable LINK;
address private immutable vrfCoordinator;
// Nonces for each VRF key from which randomness has been requested.
//
// Must stay in sync with VRFCoordinator[_keyHash][this]
mapping(bytes32 => uint256) /* keyHash */ /* nonce */
private nonces;
/**
* @param _vrfCoordinator address of VRFCoordinator contract
* @param _link address of LINK token contract
*
* @dev https://docs.chain.link/docs/link-token-contracts
*/
constructor(address _vrfCoordinator, address _link) {
vrfCoordinator = _vrfCoordinator;
LINK = LinkTokenInterface(_link);
}
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
fulfillRandomness(requestId, randomness);
}
}
pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool success);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool success);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract VRFRequestIDBase {
/**
* @notice returns the seed which is actually input to the VRF coordinator
*
* @dev To prevent repetition of VRF output due to repetition of the
* @dev user-supplied seed, that seed is combined in a hash with the
* @dev user-specific nonce, and the address of the consuming contract. The
* @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
* @dev the final seed, but the nonce does protect against repetition in
* @dev requests which are included in a single block.
*
* @param _userSeed VRF seed input provided by user
* @param _requester Address of the requesting contract
* @param _nonce User-specific nonce at the time of the request
*/
function makeVRFInputSeed(
bytes32 _keyHash,
uint256 _userSeed,
address _requester,
uint256 _nonce
) internal pure returns (uint256) {
return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
}
/**
* @notice Returns the id for this request
* @param _keyHash The serviceAgreement ID to be used for this request
* @param _vRFInputSeed The seed to be passed directly to the VRF
* @return The id for this request
*
* @dev Note that _vRFInputSeed is not the seed passed by the consuming
* @dev contract, but the one generated by makeVRFInputSeed
*/
function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
}
}